diff --git a/Assignments/Building_your_Deep_Neural_Network_Step_by_Step.ipynb b/Assignments/Building_your_Deep_Neural_Network_Step_by_Step.ipynb new file mode 100644 index 0000000..23230d1 --- /dev/null +++ b/Assignments/Building_your_Deep_Neural_Network_Step_by_Step.ipynb @@ -0,0 +1,1931 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building your Deep Neural Network: Step by Step\n", + "\n", + "Welcome to your week 4 assignment (part 1 of 2)! Previously you trained a 2-layer Neural Network with a single hidden layer. This week, you will build a deep neural network with as many layers as you want!\n", + "\n", + "- In this notebook, you'll implement all the functions required to build a deep neural network.\n", + "- For the next assignment, you'll use these functions to build a deep neural network for image classification.\n", + "\n", + "**By the end of this assignment, you'll be able to:**\n", + "\n", + "- Use non-linear units like ReLU to improve your model\n", + "- Build a deeper neural network (with more than 1 hidden layer)\n", + "- Implement an easy-to-use neural network class\n", + "\n", + "**Notation**:\n", + "- Superscript $[l]$ denotes a quantity associated with the $l^{th}$ layer. \n", + " - Example: $a^{[L]}$ is the $L^{th}$ layer activation. $W^{[L]}$ and $b^{[L]}$ are the $L^{th}$ layer parameters.\n", + "- Superscript $(i)$ denotes a quantity associated with the $i^{th}$ example. \n", + " - Example: $x^{(i)}$ is the $i^{th}$ training example.\n", + "- Lowerscript $i$ denotes the $i^{th}$ entry of a vector.\n", + " - Example: $a^{[l]}_i$ denotes the $i^{th}$ entry of the $l^{th}$ layer's activations).\n", + "\n", + "Let's get started!\n", + "\n", + "## Important Note on Submission to the AutoGrader\n", + "\n", + "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n", + "\n", + "1. You have not added any _extra_ `print` statement(s) in the assignment.\n", + "2. You have not added any _extra_ code cell(s) in the assignment.\n", + "3. You have not changed any of the function parameters.\n", + "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n", + "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n", + "\n", + "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/neural-networks-deep-learning/supplement/iLwon/h-ow-to-refresh-your-workspace)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "- [1 - Packages](#1)\n", + "- [2 - Outline](#2)\n", + "- [3 - Initialization](#3)\n", + " - [3.1 - 2-layer Neural Network](#3-1)\n", + " - [Exercise 1 - initialize_parameters](#ex-1)\n", + " - [3.2 - L-layer Neural Network](#3-2)\n", + " - [Exercise 2 - initialize_parameters_deep](#ex-2)\n", + "- [4 - Forward Propagation Module](#4)\n", + " - [4.1 - Linear Forward](#4-1)\n", + " - [Exercise 3 - linear_forward](#ex-3)\n", + " - [4.2 - Linear-Activation Forward](#4-2)\n", + " - [Exercise 4 - linear_activation_forward](#ex-4)\n", + " - [4.3 - L-Layer Model](#4-3)\n", + " - [Exercise 5 - L_model_forward](#ex-5)\n", + "- [5 - Cost Function](#5)\n", + " - [Exercise 6 - compute_cost](#ex-6)\n", + "- [6 - Backward Propagation Module](#6)\n", + " - [6.1 - Linear Backward](#6-1)\n", + " - [Exercise 7 - linear_backward](#ex-7)\n", + " - [6.2 - Linear-Activation Backward](#6-2)\n", + " - [Exercise 8 - linear_activation_backward](#ex-8)\n", + " - [6.3 - L-Model Backward](#6-3)\n", + " - [Exercise 9 - L_model_backward](#ex-9)\n", + " - [6.4 - Update Parameters](#6-4)\n", + " - [Exercise 10 - update_parameters](#ex-10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Packages\n", + "\n", + "First, import all the packages you'll need during this assignment. \n", + "\n", + "- [numpy](www.numpy.org) is the main package for scientific computing with Python.\n", + "- [matplotlib](http://matplotlib.org) is a library to plot graphs in Python.\n", + "- dnn_utils provides some necessary functions for this notebook.\n", + "- testCases provides some test cases to assess the correctness of your functions\n", + "- np.random.seed(1) is used to keep all the random function calls consistent. It helps grade your work. Please don't change the seed! " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "from testCases import *\n", + "from dnn_utils import sigmoid, sigmoid_backward, relu, relu_backward\n", + "from public_tests import *\n", + "\n", + "import copy\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "np.random.seed(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Outline\n", + "\n", + "To build your neural network, you'll be implementing several \"helper functions.\" These helper functions will be used in the next assignment to build a two-layer neural network and an L-layer neural network. \n", + "\n", + "Each small helper function will have detailed instructions to walk you through the necessary steps. Here's an outline of the steps in this assignment:\n", + "\n", + "- Initialize the parameters for a two-layer network and for an $L$-layer neural network\n", + "- Implement the forward propagation module (shown in purple in the figure below)\n", + " - Complete the LINEAR part of a layer's forward propagation step (resulting in $Z^{[l]}$).\n", + " - The ACTIVATION function is provided for you (relu/sigmoid)\n", + " - Combine the previous two steps into a new [LINEAR->ACTIVATION] forward function.\n", + " - Stack the [LINEAR->RELU] forward function L-1 time (for layers 1 through L-1) and add a [LINEAR->SIGMOID] at the end (for the final layer $L$). This gives you a new L_model_forward function.\n", + "- Compute the loss\n", + "- Implement the backward propagation module (denoted in red in the figure below)\n", + " - Complete the LINEAR part of a layer's backward propagation step\n", + " - The gradient of the ACTIVATION function is provided for you(relu_backward/sigmoid_backward) \n", + " - Combine the previous two steps into a new [LINEAR->ACTIVATION] backward function\n", + " - Stack [LINEAR->RELU] backward L-1 times and add [LINEAR->SIGMOID] backward in a new L_model_backward function\n", + "- Finally, update the parameters\n", + "\n", + "\n", + "
Figure 1

\n", + "\n", + "\n", + "**Note**:\n", + "\n", + "For every forward function, there is a corresponding backward function. This is why at every step of your forward module you will be storing some values in a cache. These cached values are useful for computing gradients. \n", + "\n", + "In the backpropagation module, you can then use the cache to calculate the gradients. Don't worry, this assignment will show you exactly how to carry out each of these steps! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3 - Initialization\n", + "\n", + "You will write two helper functions to initialize the parameters for your model. The first function will be used to initialize parameters for a two layer model. The second one generalizes this initialization process to $L$ layers.\n", + "\n", + "\n", + "### 3.1 - 2-layer Neural Network\n", + "\n", + "\n", + "### Exercise 1 - initialize_parameters\n", + "\n", + "Create and initialize the parameters of the 2-layer neural network.\n", + "\n", + "**Instructions**:\n", + "\n", + "- The model's structure is: *LINEAR -> RELU -> LINEAR -> SIGMOID*. \n", + "- Use this random initialization for the weight matrices: `np.random.randn(d0, d1, ..., dn) * 0.01` with the correct shape. The documentation for [np.random.randn](https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html)\n", + "- Use zero initialization for the biases: `np.zeros(shape)`. The documentation for [np.zeros](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c468c89deb6d0cacf2ade5ab4151d26e", + "grade": false, + "grade_id": "cell-96d4e144d9419b32", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: initialize_parameters\n", + "\n", + "def initialize_parameters(n_x, n_h, n_y):\n", + " \"\"\"\n", + " Argument:\n", + " n_x -- size of the input layer\n", + " n_h -- size of the hidden layer\n", + " n_y -- size of the output layer\n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing your parameters:\n", + " W1 -- weight matrix of shape (n_h, n_x)\n", + " b1 -- bias vector of shape (n_h, 1)\n", + " W2 -- weight matrix of shape (n_y, n_h)\n", + " b2 -- bias vector of shape (n_y, 1)\n", + " \"\"\"\n", + " \n", + " np.random.seed(1)\n", + " \n", + " #(≈ 4 lines of code)\n", + " # W1 = ...\n", + " # b1 = ...\n", + " # W2 = ...\n", + " # b2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1=np.random.randn(n_h,n_x)*0.01\n", + " b1=np.zeros((n_h,1))\n", + " W2=np.random.randn(n_y,n_h)*0.01\n", + " b2=np.zeros((n_y,1))\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " parameters = {\"W1\": W1,\n", + " \"b1\": b1,\n", + " \"W2\": W2,\n", + " \"b2\": b2}\n", + " \n", + " return parameters " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "276589230f938bc139a103fed96d590f", + "grade": true, + "grade_id": "cell-4b2bdbdd0f520c8d", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Case 1:\n", + "\n", + "W1 = [[ 0.01624345 -0.00611756 -0.00528172]\n", + " [-0.01072969 0.00865408 -0.02301539]]\n", + "b1 = [[0.]\n", + " [0.]]\n", + "W2 = [[ 0.01744812 -0.00761207]]\n", + "b2 = [[0.]]\n", + "\u001b[92m All tests passed.\n", + "\u001b[90m\n", + "Test Case 2:\n", + "\n", + "W1 = [[ 0.01624345 -0.00611756 -0.00528172 -0.01072969]\n", + " [ 0.00865408 -0.02301539 0.01744812 -0.00761207]\n", + " [ 0.00319039 -0.0024937 0.01462108 -0.02060141]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.00322417 -0.00384054 0.01133769]\n", + " [-0.01099891 -0.00172428 -0.00877858]]\n", + "b2 = [[0.]\n", + " [0.]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "print(\"Test Case 1:\\n\")\n", + "parameters = initialize_parameters(3,2,1)\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "initialize_parameters_test_1(initialize_parameters)\n", + "\n", + "print(\"\\033[90m\\nTest Case 2:\\n\")\n", + "parameters = initialize_parameters(4,3,2)\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "initialize_parameters_test_2(initialize_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "Test Case 1:\n", + "\n", + "W1 = [[ 0.01624345 -0.00611756 -0.00528172]\n", + " [-0.01072969 0.00865408 -0.02301539]]\n", + "b1 = [[0.]\n", + " [0.]]\n", + "W2 = [[ 0.01744812 -0.00761207]]\n", + "b2 = [[0.]]\n", + " All tests passed.\n", + "\n", + "Test Case 2:\n", + "\n", + "W1 = [[ 0.01624345 -0.00611756 -0.00528172 -0.01072969]\n", + " [ 0.00865408 -0.02301539 0.01744812 -0.00761207]\n", + " [ 0.00319039 -0.0024937 0.01462108 -0.02060141]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.00322417 -0.00384054 0.01133769]\n", + " [-0.01099891 -0.00172428 -0.00877858]]\n", + "b2 = [[0.]\n", + " [0.]]\n", + " All tests passed.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.2 - L-layer Neural Network\n", + "\n", + "The initialization for a deeper L-layer neural network is more complicated because there are many more weight matrices and bias vectors. When completing the `initialize_parameters_deep` function, you should make sure that your dimensions match between each layer. Recall that $n^{[l]}$ is the number of units in layer $l$. For example, if the size of your input $X$ is $(12288, 209)$ (with $m=209$ examples) then:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Shape of W Shape of b Activation Shape of Activation
Layer 1 $(n^{[1]},12288)$ $(n^{[1]},1)$ $Z^{[1]} = W^{[1]} X + b^{[1]} $ $(n^{[1]},209)$
Layer 2 $(n^{[2]}, n^{[1]})$ $(n^{[2]},1)$ $Z^{[2]} = W^{[2]} A^{[1]} + b^{[2]}$ $(n^{[2]}, 209)$
$\\vdots$ $\\vdots$ $\\vdots$ $\\vdots$ $\\vdots$
Layer L-1 $(n^{[L-1]}, n^{[L-2]})$ $(n^{[L-1]}, 1)$ $Z^{[L-1]} = W^{[L-1]} A^{[L-2]} + b^{[L-1]}$ $(n^{[L-1]}, 209)$
Layer L $(n^{[L]}, n^{[L-1]})$ $(n^{[L]}, 1)$ $Z^{[L]} = W^{[L]} A^{[L-1]} + b^{[L]}$ $(n^{[L]}, 209)$
\n", + "\n", + "Remember that when you compute $W X + b$ in python, it carries out broadcasting. For example, if: \n", + "\n", + "$$ W = \\begin{bmatrix}\n", + " w_{00} & w_{01} & w_{02} \\\\\n", + " w_{10} & w_{11} & w_{12} \\\\\n", + " w_{20} & w_{21} & w_{22} \n", + "\\end{bmatrix}\\;\\;\\; X = \\begin{bmatrix}\n", + " x_{00} & x_{01} & x_{02} \\\\\n", + " x_{10} & x_{11} & x_{12} \\\\\n", + " x_{20} & x_{21} & x_{22} \n", + "\\end{bmatrix} \\;\\;\\; b =\\begin{bmatrix}\n", + " b_0 \\\\\n", + " b_1 \\\\\n", + " b_2\n", + "\\end{bmatrix}\\tag{2}$$\n", + "\n", + "Then $WX + b$ will be:\n", + "\n", + "$$ WX + b = \\begin{bmatrix}\n", + " (w_{00}x_{00} + w_{01}x_{10} + w_{02}x_{20}) + b_0 & (w_{00}x_{01} + w_{01}x_{11} + w_{02}x_{21}) + b_0 & \\cdots \\\\\n", + " (w_{10}x_{00} + w_{11}x_{10} + w_{12}x_{20}) + b_1 & (w_{10}x_{01} + w_{11}x_{11} + w_{12}x_{21}) + b_1 & \\cdots \\\\\n", + " (w_{20}x_{00} + w_{21}x_{10} + w_{22}x_{20}) + b_2 & (w_{20}x_{01} + w_{21}x_{11} + w_{22}x_{21}) + b_2 & \\cdots\n", + "\\end{bmatrix}\\tag{3} $$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 2 - initialize_parameters_deep\n", + "\n", + "Implement initialization for an L-layer Neural Network. \n", + "\n", + "**Instructions**:\n", + "- The model's structure is *[LINEAR -> RELU] $ \\times$ (L-1) -> LINEAR -> SIGMOID*. I.e., it has $L-1$ layers using a ReLU activation function followed by an output layer with a sigmoid activation function.\n", + "- Use random initialization for the weight matrices. Use `np.random.randn(d0, d1, ..., dn) * 0.01`.\n", + "- Use zeros initialization for the biases. Use `np.zeros(shape)`.\n", + "- You'll store $n^{[l]}$, the number of units in different layers, in a variable `layer_dims`. For example, the `layer_dims` for last week's Planar Data classification model would have been [2,4,1]: There were two inputs, one hidden layer with 4 hidden units, and an output layer with 1 output unit. This means `W1`'s shape was (4,2), `b1` was (4,1), `W2` was (1,4) and `b2` was (1,1). Now you will generalize this to $L$ layers! \n", + "- Here is the implementation for $L=1$ (one layer neural network). It should inspire you to implement the general case (L-layer neural network).\n", + "```python\n", + " if L == 1:\n", + " parameters[\"W\" + str(L)] = np.random.randn(layer_dims[1], layer_dims[0]) * 0.01\n", + " parameters[\"b\" + str(L)] = np.zeros((layer_dims[1], 1))\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "1773f5c69d941998dc8da88f4151e8d3", + "grade": false, + "grade_id": "cell-37b22e0664a4949e", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: initialize_parameters_deep\n", + "\n", + "def initialize_parameters_deep(layer_dims):\n", + " \"\"\"\n", + " Arguments:\n", + " layer_dims -- python array (list) containing the dimensions of each layer in our network\n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing your parameters \"W1\", \"b1\", ..., \"WL\", \"bL\":\n", + " Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])\n", + " bl -- bias vector of shape (layer_dims[l], 1)\n", + " \"\"\"\n", + " \n", + " np.random.seed(3)\n", + " parameters = {}\n", + " L = len(layer_dims) # number of layers in the network\n", + "\n", + " for l in range(1, L):\n", + " #(≈ 2 lines of code)\n", + " # parameters['W' + str(l)] = ...\n", + " # parameters['b' + str(l)] = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters['W'+str(l)]=np.random.randn(layer_dims[l],layer_dims[l-1])*0.01\n", + " parameters['b'+str(l)]=np.zeros((layer_dims[l],1)) \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l - 1]))\n", + " assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))\n", + "\n", + " \n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "cbe5dc6d38bb4b5f14b808945d135929", + "grade": true, + "grade_id": "cell-2ce3df377bb42f76", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Case 1:\n", + "\n", + "W1 = [[ 0.01788628 0.0043651 0.00096497 -0.01863493 -0.00277388]\n", + " [-0.00354759 -0.00082741 -0.00627001 -0.00043818 -0.00477218]\n", + " [-0.01313865 0.00884622 0.00881318 0.01709573 0.00050034]\n", + " [-0.00404677 -0.0054536 -0.01546477 0.00982367 -0.01101068]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.01185047 -0.0020565 0.01486148 0.00236716]\n", + " [-0.01023785 -0.00712993 0.00625245 -0.00160513]\n", + " [-0.00768836 -0.00230031 0.00745056 0.01976111]]\n", + "b2 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + "\u001b[92m All tests passed.\n", + "\u001b[90m\n", + "Test Case 2:\n", + "\n", + "W1 = [[ 0.01788628 0.0043651 0.00096497 -0.01863493]\n", + " [-0.00277388 -0.00354759 -0.00082741 -0.00627001]\n", + " [-0.00043818 -0.00477218 -0.01313865 0.00884622]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[ 0.00881318 0.01709573 0.00050034]\n", + " [-0.00404677 -0.0054536 -0.01546477]]\n", + "b2 = [[0.]\n", + " [0.]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "print(\"Test Case 1:\\n\")\n", + "parameters = initialize_parameters_deep([5,4,3])\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "initialize_parameters_deep_test_1(initialize_parameters_deep)\n", + "\n", + "print(\"\\033[90m\\nTest Case 2:\\n\")\n", + "parameters = initialize_parameters_deep([4,3,2])\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "initialize_parameters_deep_test_2(initialize_parameters_deep)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "Test Case 1:\n", + "\n", + "W1 = [[ 0.01788628 0.0043651 0.00096497 -0.01863493 -0.00277388]\n", + " [-0.00354759 -0.00082741 -0.00627001 -0.00043818 -0.00477218]\n", + " [-0.01313865 0.00884622 0.00881318 0.01709573 0.00050034]\n", + " [-0.00404677 -0.0054536 -0.01546477 0.00982367 -0.01101068]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.01185047 -0.0020565 0.01486148 0.00236716]\n", + " [-0.01023785 -0.00712993 0.00625245 -0.00160513]\n", + " [-0.00768836 -0.00230031 0.00745056 0.01976111]]\n", + "b2 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + " All tests passed.\n", + "\n", + "Test Case 2:\n", + "\n", + "W1 = [[ 0.01788628 0.0043651 0.00096497 -0.01863493]\n", + " [-0.00277388 -0.00354759 -0.00082741 -0.00627001]\n", + " [-0.00043818 -0.00477218 -0.01313865 0.00884622]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[ 0.00881318 0.01709573 0.00050034]\n", + " [-0.00404677 -0.0054536 -0.01546477]]\n", + "b2 = [[0.]\n", + " [0.]]\n", + " All tests passed.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Forward Propagation Module\n", + "\n", + "\n", + "### 4.1 - Linear Forward \n", + "\n", + "Now that you have initialized your parameters, you can do the forward propagation module. Start by implementing some basic functions that you can use again later when implementing the model. Now, you'll complete three functions in this order:\n", + "\n", + "- LINEAR\n", + "- LINEAR -> ACTIVATION where ACTIVATION will be either ReLU or Sigmoid. \n", + "- [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID (whole model)\n", + "\n", + "The linear forward module (vectorized over all the examples) computes the following equations:\n", + "\n", + "$$Z^{[l]} = W^{[l]}A^{[l-1]} +b^{[l]}\\tag{4}$$\n", + "\n", + "where $A^{[0]} = X$. \n", + "\n", + "\n", + "### Exercise 3 - linear_forward \n", + "\n", + "Build the linear part of forward propagation.\n", + "\n", + "**Reminder**:\n", + "The mathematical representation of this unit is $Z^{[l]} = W^{[l]}A^{[l-1]} +b^{[l]}$. You may also find `np.dot()` useful. If your dimensions don't match, printing `W.shape` may help." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "770763ab229ee87e8f5dfd520428caa3", + "grade": false, + "grade_id": "cell-4d6e09486a53f4c4", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: linear_forward\n", + "\n", + "def linear_forward(A, W, b):\n", + " \"\"\"\n", + " Implement the linear part of a layer's forward propagation.\n", + "\n", + " Arguments:\n", + " A -- activations from previous layer (or input data): (size of previous layer, number of examples)\n", + " W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n", + " b -- bias vector, numpy array of shape (size of the current layer, 1)\n", + "\n", + " Returns:\n", + " Z -- the input of the activation function, also called pre-activation parameter \n", + " cache -- a python tuple containing \"A\", \"W\" and \"b\" ; stored for computing the backward pass efficiently\n", + " \"\"\"\n", + " \n", + " #(≈ 1 line of code)\n", + " # Z = ...\n", + " # YOUR CODE STARTS HERE\n", + " Z=np.dot(W,A)+b\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " cache = (A, W, b)\n", + " \n", + " return Z, cache" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e3fd70fd81b04a2c70f37588ee21140c", + "grade": true, + "grade_id": "cell-df6ddb1e30f9c96d", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Z = [[ 3.26295337 -1.23429987]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_A, t_W, t_b = linear_forward_test_case()\n", + "t_Z, t_linear_cache = linear_forward(t_A, t_W, t_b)\n", + "print(\"Z = \" + str(t_Z))\n", + "\n", + "linear_forward_test(linear_forward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "Z = [[ 3.26295337 -1.23429987]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.2 - Linear-Activation Forward\n", + "\n", + "In this notebook, you will use two activation functions:\n", + "\n", + "- **Sigmoid**: $\\sigma(Z) = \\sigma(W A + b) = \\frac{1}{ 1 + e^{-(W A + b)}}$. You've been provided with the `sigmoid` function which returns **two** items: the activation value \"`a`\" and a \"`cache`\" that contains \"`Z`\" (it's what we will feed in to the corresponding backward function). To use it you could just call: \n", + "``` python\n", + "A, activation_cache = sigmoid(Z)\n", + "```\n", + "\n", + "- **ReLU**: The mathematical formula for ReLu is $A = RELU(Z) = max(0, Z)$. You've been provided with the `relu` function. This function returns **two** items: the activation value \"`A`\" and a \"`cache`\" that contains \"`Z`\" (it's what you'll feed in to the corresponding backward function). To use it you could just call:\n", + "``` python\n", + "A, activation_cache = relu(Z)\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For added convenience, you're going to group two functions (Linear and Activation) into one function (LINEAR->ACTIVATION). Hence, you'll implement a function that does the LINEAR forward step, followed by an ACTIVATION forward step.\n", + "\n", + "\n", + "### Exercise 4 - linear_activation_forward\n", + "\n", + "Implement the forward propagation of the *LINEAR->ACTIVATION* layer. Mathematical relation is: $A^{[l]} = g(Z^{[l]}) = g(W^{[l]}A^{[l-1]} +b^{[l]})$ where the activation \"g\" can be sigmoid() or relu(). Use `linear_forward()` and the correct activation function." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "f09e76f2a56c8ee77db3e89214a676b2", + "grade": false, + "grade_id": "cell-eb48903dd8e48a90", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: linear_activation_forward\n", + "\n", + "def linear_activation_forward(A_prev, W, b, activation):\n", + " \"\"\"\n", + " Implement the forward propagation for the LINEAR->ACTIVATION layer\n", + "\n", + " Arguments:\n", + " A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)\n", + " W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)\n", + " b -- bias vector, numpy array of shape (size of the current layer, 1)\n", + " activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n", + "\n", + " Returns:\n", + " A -- the output of the activation function, also called the post-activation value \n", + " cache -- a python tuple containing \"linear_cache\" and \"activation_cache\";\n", + " stored for computing the backward pass efficiently\n", + " \"\"\"\n", + " \n", + " if activation == \"sigmoid\":\n", + " #(≈ 2 lines of code)\n", + " # Z, linear_cache = ...\n", + " # A, activation_cache = ...\n", + " # YOUR CODE STARTS HERE\n", + " Z,linear_cache=linear_forward(A_prev,W,b)\n", + " A,activation_cache=sigmoid(Z)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " elif activation == \"relu\":\n", + " #(≈ 2 lines of code)\n", + " # Z, linear_cache = ...\n", + " # A, activation_cache = ...\n", + " # YOUR CODE STARTS HERE\n", + " Z,linear_cache=linear_forward(A_prev,W,b)\n", + " A,activation_cache=relu(Z)\n", + " # YOUR CODE ENDS HERE\n", + " cache = (linear_cache, activation_cache)\n", + "\n", + " return A, cache" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "2b2a80630d2ecb9d03df4ecf6d76170d", + "grade": true, + "grade_id": "cell-ed5c76db14d687dd", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With sigmoid: A = [[0.96890023 0.11013289]]\n", + "With ReLU: A = [[3.43896131 0. ]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_A_prev, t_W, t_b = linear_activation_forward_test_case()\n", + "\n", + "t_A, t_linear_activation_cache = linear_activation_forward(t_A_prev, t_W, t_b, activation = \"sigmoid\")\n", + "print(\"With sigmoid: A = \" + str(t_A))\n", + "\n", + "t_A, t_linear_activation_cache = linear_activation_forward(t_A_prev, t_W, t_b, activation = \"relu\")\n", + "print(\"With ReLU: A = \" + str(t_A))\n", + "\n", + "linear_activation_forward_test(linear_activation_forward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "With sigmoid: A = [[0.96890023 0.11013289]]\n", + "With ReLU: A = [[3.43896131 0. ]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: In deep learning, the \"[LINEAR->ACTIVATION]\" computation is counted as a single layer in the neural network, not two layers. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.3 - L-Layer Model \n", + "\n", + "For even *more* convenience when implementing the $L$-layer Neural Net, you will need a function that replicates the previous one (`linear_activation_forward` with RELU) $L-1$ times, then follows that with one `linear_activation_forward` with SIGMOID.\n", + "\n", + "\n", + "
Figure 2 : *[LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID* model

\n", + "\n", + "\n", + "### Exercise 5 - L_model_forward\n", + "\n", + "Implement the forward propagation of the above model.\n", + "\n", + "**Instructions**: In the code below, the variable `AL` will denote $A^{[L]} = \\sigma(Z^{[L]}) = \\sigma(W^{[L]} A^{[L-1]} + b^{[L]})$. (This is sometimes also called `Yhat`, i.e., this is $\\hat{Y}$.) \n", + "\n", + "**Hints**:\n", + "- Use the functions you've previously written \n", + "- Use a for loop to replicate [LINEAR->RELU] (L-1) times\n", + "- Don't forget to keep track of the caches in the \"caches\" list. To add a new value `c` to a `list`, you can use `list.append(c)`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "a0071c19f83d4b851dc8a67e66545262", + "grade": false, + "grade_id": "cell-9a8ec52ec8f6e04a", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: L_model_forward\n", + "\n", + "def L_model_forward(X, parameters):\n", + " \"\"\"\n", + " Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation\n", + " \n", + " Arguments:\n", + " X -- data, numpy array of shape (input size, number of examples)\n", + " parameters -- output of initialize_parameters_deep()\n", + " \n", + " Returns:\n", + " AL -- activation value from the output (last) layer\n", + " caches -- list of caches containing:\n", + " every cache of linear_activation_forward() (there are L of them, indexed from 0 to L-1)\n", + " \"\"\"\n", + "\n", + " caches = []\n", + " A = X\n", + " L = len(parameters) // 2 # number of layers in the neural network\n", + " \n", + " # Implement [LINEAR -> RELU]*(L-1). Add \"cache\" to the \"caches\" list.\n", + " # The for loop starts at 1 because layer 0 is the input\n", + " for l in range(1, L):\n", + " A_prev = A \n", + " #(≈ 2 lines of code)\n", + " # A, cache = ...\n", + " # caches ...\n", + " # YOUR CODE STARTS HERE\n", + " W=parameters['W'+str(l)]\n", + " b=parameters['b'+str(l)]\n", + " A,cache=linear_activation_forward(A_prev,W,b,'relu')\n", + " caches.append(cache)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Implement LINEAR -> SIGMOID. Add \"cache\" to the \"caches\" list.\n", + " #(≈ 2 lines of code)\n", + " # AL, cache = ...\n", + " # caches ...\n", + " # YOUR CODE STARTS HERE\n", + " W=parameters['W'+str(L)]\n", + " b=parameters['b'+str(L)]\n", + " AL,cache=linear_activation_forward(A,W,b,'sigmoid')\n", + " caches.append(cache)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return AL, caches" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "18d99d8170d2fed802a3e97e362339c6", + "grade": true, + "grade_id": "cell-ddc3a524cd1a0782", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AL = [[0.03921668 0.70498921 0.19734387 0.04728177]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_X, t_parameters = L_model_forward_test_case_2hidden()\n", + "t_AL, t_caches = L_model_forward(t_X, t_parameters)\n", + "\n", + "print(\"AL = \" + str(t_AL))\n", + "\n", + "L_model_forward_test(L_model_forward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "AL = [[0.03921668 0.70498921 0.19734387 0.04728177]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Awesome!** You've implemented a full forward propagation that takes the input X and outputs a row vector $A^{[L]}$ containing your predictions. It also records all intermediate values in \"caches\". Using $A^{[L]}$, you can compute the cost of your predictions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5 - Cost Function\n", + "\n", + "Now you can implement forward and backward propagation! You need to compute the cost, in order to check whether your model is actually learning.\n", + "\n", + "\n", + "### Exercise 6 - compute_cost\n", + "Compute the cross-entropy cost $J$, using the following formula: $$-\\frac{1}{m} \\sum\\limits_{i = 1}^{m} (y^{(i)}\\log\\left(a^{[L] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[L](i)}\\right)) \\tag{7}$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "17919bb7d82635554b52aed7e96e8d9b", + "grade": false, + "grade_id": "cell-abad606772066f14", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: compute_cost\n", + "\n", + "def compute_cost(AL, Y):\n", + " \"\"\"\n", + " Implement the cost function defined by equation (7).\n", + "\n", + " Arguments:\n", + " AL -- probability vector corresponding to your label predictions, shape (1, number of examples)\n", + " Y -- true \"label\" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)\n", + "\n", + " Returns:\n", + " cost -- cross-entropy cost\n", + " \"\"\"\n", + " \n", + " m = Y.shape[1]\n", + "\n", + " # Compute loss from aL and y.\n", + " # (≈ 1 lines of code)\n", + " # cost = ...\n", + " # YOUR CODE STARTS HERE\n", + " cost=-1/m*np.sum(np.multiply(Y,np.log(AL))+(1-Y)*(np.log(1-AL)))\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n", + "\n", + " \n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "913bc99f9f1380196c0f88d82d1af893", + "grade": true, + "grade_id": "cell-e82b9dd1fa6e970b", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost: 0.2797765635793422\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_Y, t_AL = compute_cost_test_case()\n", + "t_cost = compute_cost(t_AL, t_Y)\n", + "\n", + "print(\"Cost: \" + str(t_cost))\n", + "\n", + "compute_cost_test(compute_cost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
cost 0.2797765635793422
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 6 - Backward Propagation Module\n", + "\n", + "Just as you did for the forward propagation, you'll implement helper functions for backpropagation. Remember that backpropagation is used to calculate the gradient of the loss function with respect to the parameters. \n", + "\n", + "**Reminder**: \n", + "\n", + "
Figure 3: Forward and Backward propagation for LINEAR->RELU->LINEAR->SIGMOID
The purple blocks represent the forward propagation, and the red blocks represent the backward propagation.
\n", + "\n", + "\n", + "\n", + "\n", + "Now, similarly to forward propagation, you're going to build the backward propagation in three steps:\n", + "1. LINEAR backward\n", + "2. LINEAR -> ACTIVATION backward where ACTIVATION computes the derivative of either the ReLU or sigmoid activation\n", + "3. [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID backward (whole model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the next exercise, you will need to remember that:\n", + "\n", + "- `b` is a matrix(np.ndarray) with 1 column and n rows, i.e: b = [[1.0], [2.0]] (remember that `b` is a constant)\n", + "- np.sum performs a sum over the elements of a ndarray\n", + "- axis=1 or axis=0 specify if the sum is carried out by rows or by columns respectively\n", + "- keepdims specifies if the original dimensions of the matrix must be kept.\n", + "- Look at the following example to clarify:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "axis=1 and keepdims=True\n", + "[[3]\n", + " [7]]\n", + "axis=1 and keepdims=False\n", + "[3 7]\n", + "axis=0 and keepdims=True\n", + "[[4 6]]\n", + "axis=0 and keepdims=False\n", + "[4 6]\n" + ] + } + ], + "source": [ + "A = np.array([[1, 2], [3, 4]])\n", + "\n", + "print('axis=1 and keepdims=True')\n", + "print(np.sum(A, axis=1, keepdims=True))\n", + "print('axis=1 and keepdims=False')\n", + "print(np.sum(A, axis=1, keepdims=False))\n", + "print('axis=0 and keepdims=True')\n", + "print(np.sum(A, axis=0, keepdims=True))\n", + "print('axis=0 and keepdims=False')\n", + "print(np.sum(A, axis=0, keepdims=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 6.1 - Linear Backward\n", + "\n", + "For layer $l$, the linear part is: $Z^{[l]} = W^{[l]} A^{[l-1]} + b^{[l]}$ (followed by an activation).\n", + "\n", + "Suppose you have already calculated the derivative $dZ^{[l]} = \\frac{\\partial \\mathcal{L} }{\\partial Z^{[l]}}$. You want to get $(dW^{[l]}, db^{[l]}, dA^{[l-1]})$.\n", + "\n", + "\n", + "
Figure 4
\n", + "\n", + "The three outputs $(dW^{[l]}, db^{[l]}, dA^{[l-1]})$ are computed using the input $dZ^{[l]}$.\n", + "\n", + "Here are the formulas you need:\n", + "$$ dW^{[l]} = \\frac{\\partial \\mathcal{J} }{\\partial W^{[l]\n", + "}} = \\frac{1}{m} dZ^{[l]} A^{[l-1] T} \\tag{8}$$\n", + "$$ db^{[l]} = \\frac{\\partial \\mathcal{J} }{\\partial b^{[l]}} = \\frac{1}{m} \\sum_{i = 1}^{m} dZ^{[l](i)}\\tag{9}$$\n", + "$$ dA^{[l-1]} = \\frac{\\partial \\mathcal{L} }{\\partial A^{[l-1]}} = W^{[l] T} dZ^{[l]} \\tag{10}$$\n", + "\n", + "\n", + "$A^{[l-1] T}$ is the transpose of $A^{[l-1]}$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 7 - linear_backward \n", + "\n", + "Use the 3 formulas above to implement `linear_backward()`.\n", + "\n", + "**Hint**:\n", + "\n", + "- In numpy you can get the transpose of an ndarray `A` using `A.T` or `A.transpose()`" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "137d11e28068848079eb6c315a59f2be", + "grade": false, + "grade_id": "cell-418e156a9203fe72", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: linear_backward\n", + "\n", + "def linear_backward(dZ, cache):\n", + " \"\"\"\n", + " Implement the linear portion of backward propagation for a single layer (layer l)\n", + "\n", + " Arguments:\n", + " dZ -- Gradient of the cost with respect to the linear output (of current layer l)\n", + " cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer\n", + "\n", + " Returns:\n", + " dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n", + " dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n", + " db -- Gradient of the cost with respect to b (current layer l), same shape as b\n", + " \"\"\"\n", + " A_prev, W, b = cache\n", + " m = A_prev.shape[1]\n", + "\n", + " ### START CODE HERE ### (≈ 3 lines of code)\n", + " # dW = ...\n", + " # db = ... sum by the rows of dZ with keepdims=True\n", + " # dA_prev = ...\n", + " # YOUR CODE STARTS HERE\n", + " dW=1/m*np.dot(dZ,A_prev.T)\n", + " db=1/m*np.sum(dZ,axis=1,keepdims=True)\n", + " dA_prev=np.dot(W.T,dZ)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return dA_prev, dW, db" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "35a1c64c59ad26318ab2f807acb9093c", + "grade": true, + "grade_id": "cell-b826650c7bd2a7ec", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dA_prev: [[-1.15171336 0.06718465 -0.3204696 2.09812712]\n", + " [ 0.60345879 -3.72508701 5.81700741 -3.84326836]\n", + " [-0.4319552 -1.30987417 1.72354705 0.05070578]\n", + " [-0.38981415 0.60811244 -1.25938424 1.47191593]\n", + " [-2.52214926 2.67882552 -0.67947465 1.48119548]]\n", + "dW: [[ 0.07313866 -0.0976715 -0.87585828 0.73763362 0.00785716]\n", + " [ 0.85508818 0.37530413 -0.59912655 0.71278189 -0.58931808]\n", + " [ 0.97913304 -0.24376494 -0.08839671 0.55151192 -0.10290907]]\n", + "db: [[-0.14713786]\n", + " [-0.11313155]\n", + " [-0.13209101]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_dZ, t_linear_cache = linear_backward_test_case()\n", + "t_dA_prev, t_dW, t_db = linear_backward(t_dZ, t_linear_cache)\n", + "\n", + "print(\"dA_prev: \" + str(t_dA_prev))\n", + "print(\"dW: \" + str(t_dW))\n", + "print(\"db: \" + str(t_db))\n", + "\n", + "linear_backward_test(linear_backward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "```\n", + "dA_prev: [[-1.15171336 0.06718465 -0.3204696 2.09812712]\n", + " [ 0.60345879 -3.72508701 5.81700741 -3.84326836]\n", + " [-0.4319552 -1.30987417 1.72354705 0.05070578]\n", + " [-0.38981415 0.60811244 -1.25938424 1.47191593]\n", + " [-2.52214926 2.67882552 -0.67947465 1.48119548]]\n", + "dW: [[ 0.07313866 -0.0976715 -0.87585828 0.73763362 0.00785716]\n", + " [ 0.85508818 0.37530413 -0.59912655 0.71278189 -0.58931808]\n", + " [ 0.97913304 -0.24376494 -0.08839671 0.55151192 -0.10290907]]\n", + "db: [[-0.14713786]\n", + " [-0.11313155]\n", + " [-0.13209101]]\n", + " ```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 6.2 - Linear-Activation Backward\n", + "\n", + "Next, you will create a function that merges the two helper functions: **`linear_backward`** and the backward step for the activation **`linear_activation_backward`**. \n", + "\n", + "To help you implement `linear_activation_backward`, two backward functions have been provided:\n", + "- **`sigmoid_backward`**: Implements the backward propagation for SIGMOID unit. You can call it as follows:\n", + "\n", + "```python\n", + "dZ = sigmoid_backward(dA, activation_cache)\n", + "```\n", + "\n", + "- **`relu_backward`**: Implements the backward propagation for RELU unit. You can call it as follows:\n", + "\n", + "```python\n", + "dZ = relu_backward(dA, activation_cache)\n", + "```\n", + "\n", + "If $g(.)$ is the activation function, \n", + "`sigmoid_backward` and `relu_backward` compute $$dZ^{[l]} = dA^{[l]} * g'(Z^{[l]}). \\tag{11}$$ \n", + "\n", + "\n", + "### Exercise 8 - linear_activation_backward\n", + "\n", + "Implement the backpropagation for the *LINEAR->ACTIVATION* layer." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "3497ac4aa36a57278edbfb84a44e1d72", + "grade": false, + "grade_id": "cell-6c59263d69168c17", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: linear_activation_backward\n", + "\n", + "def linear_activation_backward(dA, cache, activation):\n", + " \"\"\"\n", + " Implement the backward propagation for the LINEAR->ACTIVATION layer.\n", + " \n", + " Arguments:\n", + " dA -- post-activation gradient for current layer l \n", + " cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently\n", + " activation -- the activation to be used in this layer, stored as a text string: \"sigmoid\" or \"relu\"\n", + " \n", + " Returns:\n", + " dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev\n", + " dW -- Gradient of the cost with respect to W (current layer l), same shape as W\n", + " db -- Gradient of the cost with respect to b (current layer l), same shape as b\n", + " \"\"\"\n", + " linear_cache, activation_cache = cache\n", + " \n", + " if activation == \"relu\":\n", + " #(≈ 2 lines of code)\n", + " # dZ = ...\n", + " # dA_prev, dW, db = ...\n", + " # YOUR CODE STARTS HERE\n", + " dZ=relu_backward(dA,activation_cache)\n", + " dA_prev,dW,db=linear_backward(dZ,linear_cache)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " elif activation == \"sigmoid\":\n", + " #(≈ 2 lines of code)\n", + " # dZ = ...\n", + " # dA_prev, dW, db = ...\n", + " # YOUR CODE STARTS HERE\n", + " dZ=sigmoid_backward(dA,activation_cache)\n", + " dA_prev,dW,db=linear_backward(dZ,linear_cache)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return dA_prev, dW, db" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "2aa3ea709e212c8d39caf189f86b5866", + "grade": true, + "grade_id": "cell-d88535fde29cd1d6", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With sigmoid: dA_prev = [[ 0.11017994 0.01105339]\n", + " [ 0.09466817 0.00949723]\n", + " [-0.05743092 -0.00576154]]\n", + "With sigmoid: dW = [[ 0.10266786 0.09778551 -0.01968084]]\n", + "With sigmoid: db = [[-0.05729622]]\n", + "With relu: dA_prev = [[ 0.44090989 0. ]\n", + " [ 0.37883606 0. ]\n", + " [-0.2298228 0. ]]\n", + "With relu: dW = [[ 0.44513824 0.37371418 -0.10478989]]\n", + "With relu: db = [[-0.20837892]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_dAL, t_linear_activation_cache = linear_activation_backward_test_case()\n", + "\n", + "t_dA_prev, t_dW, t_db = linear_activation_backward(t_dAL, t_linear_activation_cache, activation = \"sigmoid\")\n", + "print(\"With sigmoid: dA_prev = \" + str(t_dA_prev))\n", + "print(\"With sigmoid: dW = \" + str(t_dW))\n", + "print(\"With sigmoid: db = \" + str(t_db))\n", + "\n", + "t_dA_prev, t_dW, t_db = linear_activation_backward(t_dAL, t_linear_activation_cache, activation = \"relu\")\n", + "print(\"With relu: dA_prev = \" + str(t_dA_prev))\n", + "print(\"With relu: dW = \" + str(t_dW))\n", + "print(\"With relu: db = \" + str(t_db))\n", + "\n", + "linear_activation_backward_test(linear_activation_backward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output:**\n", + "\n", + "```\n", + "With sigmoid: dA_prev = [[ 0.11017994 0.01105339]\n", + " [ 0.09466817 0.00949723]\n", + " [-0.05743092 -0.00576154]]\n", + "With sigmoid: dW = [[ 0.10266786 0.09778551 -0.01968084]]\n", + "With sigmoid: db = [[-0.05729622]]\n", + "With relu: dA_prev = [[ 0.44090989 0. ]\n", + " [ 0.37883606 0. ]\n", + " [-0.2298228 0. ]]\n", + "With relu: dW = [[ 0.44513824 0.37371418 -0.10478989]]\n", + "With relu: db = [[-0.20837892]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 6.3 - L-Model Backward \n", + "\n", + "Now you will implement the backward function for the whole network! \n", + "\n", + "Recall that when you implemented the `L_model_forward` function, at each iteration, you stored a cache which contains (X,W,b, and z). In the back propagation module, you'll use those variables to compute the gradients. Therefore, in the `L_model_backward` function, you'll iterate through all the hidden layers backward, starting from layer $L$. On each step, you will use the cached values for layer $l$ to backpropagate through layer $l$. Figure 5 below shows the backward pass. \n", + "\n", + "\n", + "\n", + "
Figure 5: Backward pass
\n", + "\n", + "**Initializing backpropagation**:\n", + "\n", + "To backpropagate through this network, you know that the output is: \n", + "$A^{[L]} = \\sigma(Z^{[L]})$. Your code thus needs to compute `dAL` $= \\frac{\\partial \\mathcal{L}}{\\partial A^{[L]}}$.\n", + "To do so, use this formula (derived using calculus which, again, you don't need in-depth knowledge of!):\n", + "```python\n", + "dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL)) # derivative of cost with respect to AL\n", + "```\n", + "\n", + "You can then use this post-activation gradient `dAL` to keep going backward. As seen in Figure 5, you can now feed in `dAL` into the LINEAR->SIGMOID backward function you implemented (which will use the cached values stored by the L_model_forward function). \n", + "\n", + "After that, you will have to use a `for` loop to iterate through all the other layers using the LINEAR->RELU backward function. You should store each dA, dW, and db in the grads dictionary. To do so, use this formula : \n", + "\n", + "$$grads[\"dW\" + str(l)] = dW^{[l]}\\tag{15} $$\n", + "\n", + "For example, for $l=3$ this would store $dW^{[l]}$ in `grads[\"dW3\"]`.\n", + "\n", + "\n", + "### Exercise 9 - L_model_backward\n", + "\n", + "Implement backpropagation for the *[LINEAR->RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID* model." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "d3e23a2b5f3b33e264a122b3c4b0d760", + "grade": false, + "grade_id": "cell-9eec96b6d83ff809", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: L_model_backward\n", + "\n", + "def L_model_backward(AL, Y, caches):\n", + " \"\"\"\n", + " Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group\n", + " \n", + " Arguments:\n", + " AL -- probability vector, output of the forward propagation (L_model_forward())\n", + " Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat)\n", + " caches -- list of caches containing:\n", + " every cache of linear_activation_forward() with \"relu\" (it's caches[l], for l in range(L-1) i.e l = 0...L-2)\n", + " the cache of linear_activation_forward() with \"sigmoid\" (it's caches[L-1])\n", + " \n", + " Returns:\n", + " grads -- A dictionary with the gradients\n", + " grads[\"dA\" + str(l)] = ... \n", + " grads[\"dW\" + str(l)] = ...\n", + " grads[\"db\" + str(l)] = ... \n", + " \"\"\"\n", + " grads = {}\n", + " L = len(caches) # the number of layers\n", + " m = AL.shape[1]\n", + " Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n", + " \n", + " # Initializing the backpropagation\n", + " #(1 line of code)\n", + " # dAL = ...\n", + " # YOUR CODE STARTS HERE\n", + " dAL=-(np.divide(Y, AL)-np.divide(1-Y,1-AL))\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: \"dAL, current_cache\". Outputs: \"grads[\"dAL-1\"], grads[\"dWL\"], grads[\"dbL\"]\n", + " #(approx. 5 lines)\n", + " # current_cache = ...\n", + " # dA_prev_temp, dW_temp, db_temp = ...\n", + " # grads[\"dA\" + str(L-1)] = ...\n", + " # grads[\"dW\" + str(L)] = ...\n", + " # grads[\"db\" + str(L)] = ...\n", + " # YOUR CODE STARTS HERE\n", + " current_cache=caches[L-1]\n", + " dA_prev,dW_temp,db_temp=linear_activation_backward(dAL, current_cache,'sigmoid')\n", + " grads['dA'+str(L-1)]=dA_prev\n", + " grads['dW'+str(L)]=dW_temp\n", + " grads['db'+str(L)]=db_temp\n", + " # YOUR CODE ENDS HERE\n", + "\n", + " # Loop from l=L-2 to l=0\n", + " for l in reversed(range(L-1)):\n", + " print(l)\n", + " # lth layer: (RELU -> LINEAR) gradients.\n", + " # Inputs: \"grads[\"dA\" + str(l + 1)], current_cache\". Outputs: \"grads[\"dA\" + str(l)] , grads[\"dW\" + str(l + 1)] , grads[\"db\" + str(l + 1)] \n", + " #(approx. 5 lines)\n", + " # current_cache = ...\n", + " # dA_prev_temp, dW_temp, db_temp = ...\n", + " # grads[\"dA\" + str(l)] = ...\n", + " # grads[\"dW\" + str(l + 1)] = ...\n", + " # grads[\"db\" + str(l + 1)] = ...\n", + " # YOUR CODE STARTS HERE\n", + " current_cache=caches[l]\n", + " dA_prev_temp=dA_prev\n", + " dA_prev_temp,dW_temp,db_temp=linear_activation_backward(dA_prev_temp, current_cache, 'relu')\n", + " grads['dA'+str(l)]=dA_prev_temp\n", + " grads['dW'+str(l+1)]=dW_temp\n", + " grads['db'+str(l+1)]=db_temp\n", + " # YOUR CODE ENDS HERE\n", + "\n", + " return grads" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c38a79bcdf2de4284faabd1b758812b5", + "grade": true, + "grade_id": "cell-7e61e6a1bfaa382d", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "dA0 = [[ 0. 0.52257901]\n", + " [ 0. -0.3269206 ]\n", + " [ 0. -0.32070404]\n", + " [ 0. -0.74079187]]\n", + "dA1 = [[ 0.12913162 -0.44014127]\n", + " [-0.14175655 0.48317296]\n", + " [ 0.01663708 -0.05670698]]\n", + "dW1 = [[0.41010002 0.07807203 0.13798444 0.10502167]\n", + " [0. 0. 0. 0. ]\n", + " [0.05283652 0.01005865 0.01777766 0.0135308 ]]\n", + "dW2 = [[-0.39202432 -0.13325855 -0.04601089]]\n", + "db1 = [[-0.22007063]\n", + " [ 0. ]\n", + " [-0.02835349]]\n", + "db2 = [[0.15187861]]\n", + "0\n", + "0\n", + "0\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_AL, t_Y_assess, t_caches = L_model_backward_test_case()\n", + "grads = L_model_backward(t_AL, t_Y_assess, t_caches)\n", + "\n", + "print(\"dA0 = \" + str(grads['dA0']))\n", + "print(\"dA1 = \" + str(grads['dA1']))\n", + "print(\"dW1 = \" + str(grads['dW1']))\n", + "print(\"dW2 = \" + str(grads['dW2']))\n", + "print(\"db1 = \" + str(grads['db1']))\n", + "print(\"db2 = \" + str(grads['db2']))\n", + "\n", + "L_model_backward_test(L_model_backward)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output:**\n", + "\n", + "```\n", + "dA0 = [[ 0. 0.52257901]\n", + " [ 0. -0.3269206 ]\n", + " [ 0. -0.32070404]\n", + " [ 0. -0.74079187]]\n", + "dA1 = [[ 0.12913162 -0.44014127]\n", + " [-0.14175655 0.48317296]\n", + " [ 0.01663708 -0.05670698]]\n", + "dW1 = [[0.41010002 0.07807203 0.13798444 0.10502167]\n", + " [0. 0. 0. 0. ]\n", + " [0.05283652 0.01005865 0.01777766 0.0135308 ]]\n", + "dW2 = [[-0.39202432 -0.13325855 -0.04601089]]\n", + "db1 = [[-0.22007063]\n", + " [ 0. ]\n", + " [-0.02835349]]\n", + "db2 = [[0.15187861]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 6.4 - Update Parameters\n", + "\n", + "In this section, you'll update the parameters of the model, using gradient descent: \n", + "\n", + "$$ W^{[l]} = W^{[l]} - \\alpha \\text{ } dW^{[l]} \\tag{16}$$\n", + "$$ b^{[l]} = b^{[l]} - \\alpha \\text{ } db^{[l]} \\tag{17}$$\n", + "\n", + "where $\\alpha$ is the learning rate. \n", + "\n", + "After computing the updated parameters, store them in the parameters dictionary. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 10 - update_parameters\n", + "\n", + "Implement `update_parameters()` to update your parameters using gradient descent.\n", + "\n", + "**Instructions**:\n", + "Update parameters using gradient descent on every $W^{[l]}$ and $b^{[l]}$ for $l = 1, 2, ..., L$. " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e5e27794edcc10ab613c3eecd83a3011", + "grade": false, + "grade_id": "cell-3cb535f16aba3339", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: update_parameters\n", + "\n", + "def update_parameters(params, grads, learning_rate):\n", + " \"\"\"\n", + " Update parameters using gradient descent\n", + " \n", + " Arguments:\n", + " params -- python dictionary containing your parameters \n", + " grads -- python dictionary containing your gradients, output of L_model_backward\n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing your updated parameters \n", + " parameters[\"W\" + str(l)] = ... \n", + " parameters[\"b\" + str(l)] = ...\n", + " \"\"\"\n", + " parameters = copy.deepcopy(params)\n", + " L = len(parameters) // 2 # number of layers in the neural network\n", + "\n", + " # Update rule for each parameter. Use a for loop.\n", + " #(≈ 2 lines of code)\n", + " for l in range(L):\n", + " # parameters[\"W\" + str(l+1)] = ...\n", + " # parameters[\"b\" + str(l+1)] = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters['W'+str(l+1)]=params['W'+str(l+1)]-learning_rate*grads['dW'+str(l+1)]\n", + " parameters['b'+str(l+1)]=params['b'+str(l+1)]-learning_rate*grads['db'+str(l+1)]\n", + " # YOUR CODE ENDS HERE\n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e0606cae114ec47754dc5383bc3dcdea", + "grade": true, + "grade_id": "cell-139de12ee845c39c", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 = [[-0.59562069 -0.09991781 -2.14584584 1.82662008]\n", + " [-1.76569676 -0.80627147 0.51115557 -1.18258802]\n", + " [-1.0535704 -0.86128581 0.68284052 2.20374577]]\n", + "b1 = [[-0.04659241]\n", + " [-1.28888275]\n", + " [ 0.53405496]]\n", + "W2 = [[-0.55569196 0.0354055 1.32964895]]\n", + "b2 = [[-0.84610769]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_parameters, grads = update_parameters_test_case()\n", + "t_parameters = update_parameters(t_parameters, grads, 0.1)\n", + "\n", + "print (\"W1 = \"+ str(t_parameters[\"W1\"]))\n", + "print (\"b1 = \"+ str(t_parameters[\"b1\"]))\n", + "print (\"W2 = \"+ str(t_parameters[\"W2\"]))\n", + "print (\"b2 = \"+ str(t_parameters[\"b2\"]))\n", + "\n", + "update_parameters_test(update_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output:**\n", + "\n", + "```\n", + "W1 = [[-0.59562069 -0.09991781 -2.14584584 1.82662008]\n", + " [-1.76569676 -0.80627147 0.51115557 -1.18258802]\n", + " [-1.0535704 -0.86128581 0.68284052 2.20374577]]\n", + "b1 = [[-0.04659241]\n", + " [-1.28888275]\n", + " [ 0.53405496]]\n", + "W2 = [[-0.55569196 0.0354055 1.32964895]]\n", + "b2 = [[-0.84610769]]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Congratulations! \n", + "\n", + "You've just implemented all the functions required for building a deep neural network, including: \n", + "\n", + "- Using non-linear units improve your model\n", + "- Building a deeper neural network (with more than 1 hidden layer)\n", + "- Implementing an easy-to-use neural network class\n", + "\n", + "This was indeed a long assignment, but the next part of the assignment is easier. ;) \n", + "\n", + "In the next assignment, you'll be putting all these together to build two models:\n", + "\n", + "- A two-layer neural network\n", + "- An L-layer neural network\n", + "\n", + "You will in fact use these models to classify cat vs non-cat images! (Meow!) Great work and see you next time. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "coursera": { + "course_slug": "neural-networks-deep-learning", + "graded_item_id": "c4HO0", + "launcher_item_id": "lSYZM" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Assignments/Deep Neural Network - Application.ipynb b/Assignments/Deep Neural Network - Application.ipynb new file mode 100644 index 0000000..60b8dd5 --- /dev/null +++ b/Assignments/Deep Neural Network - Application.ipynb @@ -0,0 +1,1187 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deep Neural Network for Image Classification: Application\n", + "\n", + "By the time you complete this notebook, you will have finished the last programming assignment of Week 4, and also the last programming assignment of Course 1! Go you! \n", + "\n", + "To build your cat/not-a-cat classifier, you'll use the functions from the previous assignment to build a deep network. Hopefully, you'll see an improvement in accuracy over your previous logistic regression implementation. \n", + "\n", + "**After this assignment you will be able to:**\n", + "\n", + "- Build and train a deep L-layer neural network, and apply it to supervised learning\n", + "\n", + "Let's get started!\n", + "\n", + "## Important Note on Submission to the AutoGrader\n", + "\n", + "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n", + "\n", + "1. You have not added any _extra_ `print` statement(s) in the assignment.\n", + "2. You have not added any _extra_ code cell(s) in the assignment.\n", + "3. You have not changed any of the function parameters.\n", + "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n", + "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n", + "\n", + "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/neural-networks-deep-learning/supplement/iLwon/h-ow-to-refresh-your-workspace)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "- [1 - Packages](#1)\n", + "- [2 - Load and Process the Dataset](#2)\n", + "- [3 - Model Architecture](#3)\n", + " - [3.1 - 2-layer Neural Network](#3-1)\n", + " - [3.2 - L-layer Deep Neural Network](#3-2)\n", + " - [3.3 - General Methodology](#3-3)\n", + "- [4 - Two-layer Neural Network](#4)\n", + " - [Exercise 1 - two_layer_model](#ex-1)\n", + " - [4.1 - Train the model](#4-1)\n", + "- [5 - L-layer Neural Network](#5)\n", + " - [Exercise 2 - L_layer_model](#ex-2)\n", + " - [5.1 - Train the model](#5-1)\n", + "- [6 - Results Analysis](#6)\n", + "- [7 - Test with your own image (optional/ungraded exercise)](#7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Packages" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Begin by importing all the packages you'll need during this assignment. \n", + "\n", + "- [numpy](https://www.numpy.org/) is the fundamental package for scientific computing with Python.\n", + "- [matplotlib](http://matplotlib.org) is a library to plot graphs in Python.\n", + "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n", + "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end.\n", + "- `dnn_app_utils` provides the functions implemented in the \"Building your Deep Neural Network: Step by Step\" assignment to this notebook.\n", + "- `np.random.seed(1)` is used to keep all the random function calls consistent. It helps grade your work - so please don't change it! " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "import h5py\n", + "import matplotlib.pyplot as plt\n", + "import scipy\n", + "from PIL import Image\n", + "from scipy import ndimage\n", + "from dnn_app_utils_v3 import *\n", + "from public_tests import *\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "np.random.seed(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Load and Process the Dataset\n", + "\n", + "You'll be using the same \"Cat vs non-Cat\" dataset as in \"Logistic Regression as a Neural Network\" (Assignment 2). The model you built back then had 70% test accuracy on classifying cat vs non-cat images. Hopefully, your new model will perform even better!\n", + "\n", + "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n", + " - a training set of `m_train` images labelled as cat (1) or non-cat (0)\n", + " - a test set of `m_test` images labelled as cat and non-cat\n", + " - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB).\n", + "\n", + "Let's get more familiar with the dataset. Load the data by running the cell below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "train_x_orig, train_y, test_x_orig, test_y, classes = load_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following code will show you an image in the dataset. Feel free to change the index and re-run the cell multiple times to check out other images. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = 0. It's a non-cat picture.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Example of a picture\n", + "index = 10\n", + "plt.imshow(train_x_orig[index])\n", + "print (\"y = \" + str(train_y[0,index]) + \". It's a \" + classes[train_y[0,index]].decode(\"utf-8\") + \" picture.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(209, 64, 64, 3)\n", + "Number of training examples: 209\n", + "Number of testing examples: 50\n", + "Each image is of size: (64, 64, 3)\n", + "train_x_orig shape: (209, 64, 64, 3)\n", + "train_y shape: (1, 209)\n", + "test_x_orig shape: (50, 64, 64, 3)\n", + "test_y shape: (1, 50)\n" + ] + } + ], + "source": [ + "# Explore your dataset \n", + "m_train = train_x_orig.shape[0]\n", + "num_px = train_x_orig.shape[1]\n", + "m_test = test_x_orig.shape[0]\n", + "print(train_x_orig.shape)\n", + "print (\"Number of training examples: \" + str(m_train))\n", + "print (\"Number of testing examples: \" + str(m_test))\n", + "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n", + "print (\"train_x_orig shape: \" + str(train_x_orig.shape))\n", + "print (\"train_y shape: \" + str(train_y.shape))\n", + "print (\"test_x_orig shape: \" + str(test_x_orig.shape))\n", + "print (\"test_y shape: \" + str(test_y.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As usual, you reshape and standardize the images before feeding them to the network. The code is given in the cell below.\n", + "\n", + "\n", + "
Figure 1: Image to vector conversion.
" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_x's shape: (12288, 209)\n", + "test_x's shape: (12288, 50)\n" + ] + } + ], + "source": [ + "# Reshape the training and test examples \n", + "train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T # The \"-1\" makes reshape flatten the remaining dimensions\n", + "test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T\n", + "\n", + "# Standardize data to have feature values between 0 and 1.\n", + "train_x = train_x_flatten/255.\n", + "test_x = test_x_flatten/255.\n", + "\n", + "print (\"train_x's shape: \" + str(train_x.shape))\n", + "print (\"test_x's shape: \" + str(test_x.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**:\n", + "$12,288$ equals $64 \\times 64 \\times 3$, which is the size of one reshaped image vector." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3 - Model Architecture" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.1 - 2-layer Neural Network\n", + "\n", + "Now that you're familiar with the dataset, it's time to build a deep neural network to distinguish cat images from non-cat images!\n", + "\n", + "You're going to build two different models:\n", + "\n", + "- A 2-layer neural network\n", + "- An L-layer deep neural network\n", + "\n", + "Then, you'll compare the performance of these models, and try out some different values for $L$. \n", + "\n", + "Let's look at the two architectures:\n", + "\n", + "\n", + "
Figure 2: 2-layer neural network.
The model can be summarized as: INPUT -> LINEAR -> RELU -> LINEAR -> SIGMOID -> OUTPUT.
\n", + "\n", + "Detailed Architecture of Figure 2:\n", + "- The input is a (64,64,3) image which is flattened to a vector of size $(12288,1)$. \n", + "- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ of size $(n^{[1]}, 12288)$.\n", + "- Then, add a bias term and take its relu to get the following vector: $[a_0^{[1]}, a_1^{[1]},..., a_{n^{[1]}-1}^{[1]}]^T$.\n", + "- Multiply the resulting vector by $W^{[2]}$ and add the intercept (bias). \n", + "- Finally, take the sigmoid of the result. If it's greater than 0.5, classify it as a cat.\n", + "\n", + "\n", + "### 3.2 - L-layer Deep Neural Network\n", + "\n", + "It's pretty difficult to represent an L-layer deep neural network using the above representation. However, here is a simplified network representation:\n", + "\n", + "\n", + "
Figure 3: L-layer neural network.
The model can be summarized as: [LINEAR -> RELU] $\\times$ (L-1) -> LINEAR -> SIGMOID
\n", + "\n", + "Detailed Architecture of Figure 3:\n", + "- The input is a (64,64,3) image which is flattened to a vector of size (12288,1).\n", + "- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ and then you add the intercept $b^{[1]}$. The result is called the linear unit.\n", + "- Next, take the relu of the linear unit. This process could be repeated several times for each $(W^{[l]}, b^{[l]})$ depending on the model architecture.\n", + "- Finally, take the sigmoid of the final linear unit. If it is greater than 0.5, classify it as a cat.\n", + "\n", + "\n", + "### 3.3 - General Methodology\n", + "\n", + "As usual, you'll follow the Deep Learning methodology to build the model:\n", + "\n", + "1. Initialize parameters / Define hyperparameters\n", + "2. Loop for num_iterations:\n", + " a. Forward propagation\n", + " b. Compute cost function\n", + " c. Backward propagation\n", + " d. Update parameters (using parameters, and grads from backprop) \n", + "3. Use trained parameters to predict labels\n", + "\n", + "Now go ahead and implement those two models!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Two-layer Neural Network\n", + "\n", + "\n", + "### Exercise 1 - two_layer_model \n", + "\n", + "Use the helper functions you have implemented in the previous assignment to build a 2-layer neural network with the following structure: *LINEAR -> RELU -> LINEAR -> SIGMOID*. The functions and their inputs are:\n", + "```python\n", + "def initialize_parameters(n_x, n_h, n_y):\n", + " ...\n", + " return parameters \n", + "def linear_activation_forward(A_prev, W, b, activation):\n", + " ...\n", + " return A, cache\n", + "def compute_cost(AL, Y):\n", + " ...\n", + " return cost\n", + "def linear_activation_backward(dA, cache, activation):\n", + " ...\n", + " return dA_prev, dW, db\n", + "def update_parameters(parameters, grads, learning_rate):\n", + " ...\n", + " return parameters\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "### CONSTANTS DEFINING THE MODEL ####\n", + "n_x = 12288 # num_px * num_px * 3\n", + "n_h = 7\n", + "n_y = 1\n", + "layers_dims = (n_x, n_h, n_y)\n", + "learning_rate = 0.0075" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "db8e38ac17a149dc8e73efffd5cfbecf", + "grade": false, + "grade_id": "cell-46e7e26fe75ece95", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: two_layer_model\n", + "\n", + "def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n", + " \"\"\"\n", + " Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.\n", + " \n", + " Arguments:\n", + " X -- input data, of shape (n_x, number of examples)\n", + " Y -- true \"label\" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)\n", + " layers_dims -- dimensions of the layers (n_x, n_h, n_y)\n", + " num_iterations -- number of iterations of the optimization loop\n", + " learning_rate -- learning rate of the gradient descent update rule\n", + " print_cost -- If set to True, this will print the cost every 100 iterations \n", + " \n", + " Returns:\n", + " parameters -- a dictionary containing W1, W2, b1, and b2\n", + " \"\"\"\n", + " \n", + " np.random.seed(1)\n", + " grads = {}\n", + " costs = [] # to keep track of the cost\n", + " m = X.shape[1] # number of examples\n", + " (n_x, n_h, n_y) = layers_dims\n", + " \n", + " # Initialize parameters dictionary, by calling one of the functions you'd previously implemented\n", + " #(≈ 1 line of code)\n", + " # parameters = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters=initialize_parameters(n_x,n_h,n_y)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Get W1, b1, W2 and b2 from the dictionary parameters.\n", + " W1 = parameters[\"W1\"]\n", + " b1 = parameters[\"b1\"]\n", + " W2 = parameters[\"W2\"]\n", + " b2 = parameters[\"b2\"]\n", + " \n", + " # Loop (gradient descent)\n", + "\n", + " for i in range(0, num_iterations):\n", + "\n", + " # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: \"X, W1, b1, W2, b2\". Output: \"A1, cache1, A2, cache2\".\n", + " #(≈ 2 lines of code)\n", + " # A1, cache1 = ...\n", + " # A2, cache2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " A1,cache1=linear_activation_forward(X,W1,b1,'relu')\n", + " A2,cache2=linear_activation_forward(A1,W2,b2,'sigmoid')\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Compute cost\n", + " #(≈ 1 line of code)\n", + " # cost = ...\n", + " # YOUR CODE STARTS HERE\n", + " cost=compute_cost(A2,Y)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Initializing backward propagation\n", + " dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))\n", + " \n", + " # Backward propagation. Inputs: \"dA2, cache2, cache1\". Outputs: \"dA1, dW2, db2; also dA0 (not used), dW1, db1\".\n", + " #(≈ 2 lines of code)\n", + " # dA1, dW2, db2 = ...\n", + " # dA0, dW1, db1 = ...\n", + " # YOUR CODE STARTS HERE\n", + " dA1,dW2,db2=linear_activation_backward(dA2,cache2,'sigmoid')\n", + " dA2,dW1,db1=linear_activation_backward(dA1,cache1,'relu')\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2\n", + " grads['dW1'] = dW1\n", + " grads['db1'] = db1\n", + " grads['dW2'] = dW2\n", + " grads['db2'] = db2\n", + " \n", + " # Update parameters.\n", + " #(approx. 1 line of code)\n", + " # parameters = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters=update_parameters(parameters,grads,learning_rate) \n", + " # YOUR CODE ENDS HERE\n", + "\n", + " # Retrieve W1, b1, W2, b2 from parameters\n", + " W1 = parameters[\"W1\"]\n", + " b1 = parameters[\"b1\"]\n", + " W2 = parameters[\"W2\"]\n", + " b2 = parameters[\"b2\"]\n", + " \n", + " # Print the cost every 100 iterations\n", + " if print_cost and i % 100 == 0 or i == num_iterations - 1:\n", + " print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n", + " if i % 100 == 0 or i == num_iterations:\n", + " costs.append(cost)\n", + "\n", + " return parameters, costs\n", + "\n", + "def plot_costs(costs, learning_rate=0.0075):\n", + " plt.plot(np.squeeze(costs))\n", + " plt.ylabel('cost')\n", + " plt.xlabel('iterations (per hundreds)')\n", + " plt.title(\"Learning rate =\" + str(learning_rate))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c4efa978eb920cd5de40eccf4c40c6e8", + "grade": true, + "grade_id": "cell-7599b81fb37ae26a", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 1: 0.6926114346158595\n", + "Cost after first iteration: 0.693049735659989\n", + "Cost after iteration 1: 0.6915746967050506\n", + "Cost after iteration 1: 0.6915746967050506\n", + "Cost after iteration 1: 0.6915746967050506\n", + "Cost after iteration 2: 0.6524135179683452\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2, print_cost=False)\n", + "\n", + "print(\"Cost after first iteration: \" + str(costs[0]))\n", + "\n", + "two_layer_model_test(two_layer_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output:**\n", + "\n", + "```\n", + "cost after iteration 1 must be around 0.69\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.1 - Train the model \n", + "\n", + "If your code passed the previous cell, run the cell below to train your parameters. \n", + "\n", + "- The cost should decrease on every iteration. \n", + "\n", + "- It may take up to 5 minutes to run 2500 iterations. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 0: 0.693049735659989\n", + "Cost after iteration 100: 0.6464320953428849\n", + "Cost after iteration 200: 0.6325140647912677\n", + "Cost after iteration 300: 0.6015024920354665\n", + "Cost after iteration 400: 0.5601966311605747\n", + "Cost after iteration 500: 0.5158304772764729\n", + "Cost after iteration 600: 0.4754901313943325\n", + "Cost after iteration 700: 0.43391631512257495\n", + "Cost after iteration 800: 0.4007977536203886\n", + "Cost after iteration 900: 0.3580705011323798\n", + "Cost after iteration 1000: 0.3394281538366413\n", + "Cost after iteration 1100: 0.30527536361962654\n", + "Cost after iteration 1200: 0.2749137728213015\n", + "Cost after iteration 1300: 0.2468176821061484\n", + "Cost after iteration 1400: 0.19850735037466102\n", + "Cost after iteration 1500: 0.17448318112556638\n", + "Cost after iteration 1600: 0.1708076297809692\n", + "Cost after iteration 1700: 0.11306524562164715\n", + "Cost after iteration 1800: 0.09629426845937156\n", + "Cost after iteration 1900: 0.0834261795972687\n", + "Cost after iteration 2000: 0.07439078704319085\n", + "Cost after iteration 2100: 0.06630748132267933\n", + "Cost after iteration 2200: 0.05919329501038172\n", + "Cost after iteration 2300: 0.053361403485605606\n", + "Cost after iteration 2400: 0.04855478562877019\n", + "Cost after iteration 2499: 0.04421498215868956\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "parameters, costs = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)\n", + "plot_costs(costs, learning_rate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Cost after iteration 0 0.6930497356599888
Cost after iteration 100 0.6464320953428849
... ...
Cost after iteration 2499 0.04421498215868956
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Nice!** You successfully trained the model. Good thing you built a vectorized implementation! Otherwise it might have taken 10 times longer to train this.\n", + "\n", + "Now, you can use the trained parameters to classify images from the dataset. To see your predictions on the training and test sets, run the cell below." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9999999999999998\n" + ] + } + ], + "source": [ + "predictions_train = predict(train_x, train_y, parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Accuracy 0.9999999999999998
" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.72\n" + ] + } + ], + "source": [ + "predictions_test = predict(test_x, test_y, parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Accuracy 0.72
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Congratulations! It seems that your 2-layer neural network has better performance (72%) than the logistic regression implementation (70%, assignment week 2). Let's see if you can do even better with an $L$-layer model.\n", + "\n", + "**Note**: You may notice that running the model on fewer iterations (say 1500) gives better accuracy on the test set. This is called \"early stopping\" and you'll hear more about it in the next course. Early stopping is a way to prevent overfitting. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5 - L-layer Neural Network\n", + "\n", + "\n", + "### Exercise 2 - L_layer_model \n", + "\n", + "Use the helper functions you implemented previously to build an $L$-layer neural network with the following structure: *[LINEAR -> RELU]$\\times$(L-1) -> LINEAR -> SIGMOID*. The functions and their inputs are:\n", + "```python\n", + "def initialize_parameters_deep(layers_dims):\n", + " ...\n", + " return parameters \n", + "def L_model_forward(X, parameters):\n", + " ...\n", + " return AL, caches\n", + "def compute_cost(AL, Y):\n", + " ...\n", + " return cost\n", + "def L_model_backward(AL, Y, caches):\n", + " ...\n", + " return grads\n", + "def update_parameters(parameters, grads, learning_rate):\n", + " ...\n", + " return parameters\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "### CONSTANTS ###\n", + "layers_dims = [12288, 20, 7, 5, 1] # 4-layer model" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "8b444dd257b73f67117533b4265ba6b4", + "grade": false, + "grade_id": "cell-dd8ea98cb7dac175", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: L_layer_model\n", + "\n", + "def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):\n", + " \"\"\"\n", + " Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.\n", + " \n", + " Arguments:\n", + " X -- input data, of shape (n_x, number of examples)\n", + " Y -- true \"label\" vector (containing 1 if cat, 0 if non-cat), of shape (1, number of examples)\n", + " layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).\n", + " learning_rate -- learning rate of the gradient descent update rule\n", + " num_iterations -- number of iterations of the optimization loop\n", + " print_cost -- if True, it prints the cost every 100 steps\n", + " \n", + " Returns:\n", + " parameters -- parameters learnt by the model. They can then be used to predict.\n", + " \"\"\"\n", + "\n", + " np.random.seed(1)\n", + " costs = [] # keep track of cost\n", + " \n", + " # Parameters initialization.\n", + " #(≈ 1 line of code)\n", + " # parameters = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters=initialize_parameters_deep(layers_dims)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Loop (gradient descent)\n", + " for i in range(0, num_iterations):\n", + "\n", + " # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.\n", + " #(≈ 1 line of code)\n", + " # AL, caches = ...\n", + " # YOUR CODE STARTS HERE\n", + " AL,caches=L_model_forward(X,parameters)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Compute cost.\n", + " #(≈ 1 line of code)\n", + " # cost = ...\n", + " # YOUR CODE STARTS HERE\n", + " cost=compute_cost(AL,Y)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Backward propagation.\n", + " #(≈ 1 line of code)\n", + " # grads = ... \n", + " # YOUR CODE STARTS HERE\n", + " grads=L_model_backward(AL,Y,caches)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Update parameters.\n", + " #(≈ 1 line of code)\n", + " # parameters = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters=update_parameters(parameters, grads, learning_rate)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Print the cost every 100 iterations\n", + " if print_cost and i % 100 == 0 or i == num_iterations - 1:\n", + " print(\"Cost after iteration {}: {}\".format(i, np.squeeze(cost)))\n", + " if i % 100 == 0 or i == num_iterations:\n", + " costs.append(cost)\n", + " \n", + " return parameters, costs" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "1f74e4d164e9274bfa921ff2ce310c93", + "grade": true, + "grade_id": "cell-ec1d0c26f291cd5f", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 0: 0.7717493284237686\n", + "Cost after first iteration: 0.7717493284237686\n", + "Cost after iteration 1: 0.7070709008912569\n", + "Cost after iteration 1: 0.7070709008912569\n", + "Cost after iteration 1: 0.7070709008912569\n", + "Cost after iteration 2: 0.7063462654190897\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 1, print_cost = False)\n", + "\n", + "print(\"Cost after first iteration: \" + str(costs[0]))\n", + "\n", + "L_layer_model_test(L_layer_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 5.1 - Train the model \n", + "\n", + "If your code passed the previous cell, run the cell below to train your model as a 4-layer neural network. \n", + "\n", + "- The cost should decrease on every iteration. \n", + "\n", + "- It may take up to 5 minutes to run 2500 iterations. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 0: 0.7717493284237686\n", + "Cost after iteration 100: 0.6720534400822914\n", + "Cost after iteration 200: 0.6482632048575212\n", + "Cost after iteration 300: 0.6115068816101356\n", + "Cost after iteration 400: 0.5670473268366111\n", + "Cost after iteration 500: 0.5401376634547801\n", + "Cost after iteration 600: 0.5279299569455267\n", + "Cost after iteration 700: 0.4654773771766851\n", + "Cost after iteration 800: 0.369125852495928\n", + "Cost after iteration 900: 0.39174697434805344\n", + "Cost after iteration 1000: 0.31518698886006163\n", + "Cost after iteration 1100: 0.2726998441789385\n", + "Cost after iteration 1200: 0.23741853400268137\n", + "Cost after iteration 1300: 0.19960120532208644\n", + "Cost after iteration 1400: 0.18926300388463307\n", + "Cost after iteration 1500: 0.16118854665827753\n", + "Cost after iteration 1600: 0.14821389662363316\n", + "Cost after iteration 1700: 0.13777487812972944\n", + "Cost after iteration 1800: 0.1297401754919012\n", + "Cost after iteration 1900: 0.12122535068005211\n", + "Cost after iteration 2000: 0.11382060668633713\n", + "Cost after iteration 2100: 0.10783928526254133\n", + "Cost after iteration 2200: 0.10285466069352679\n", + "Cost after iteration 2300: 0.10089745445261786\n", + "Cost after iteration 2400: 0.09287821526472398\n", + "Cost after iteration 2499: 0.08843994344170202\n" + ] + } + ], + "source": [ + "parameters, costs = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Cost after iteration 0 0.771749
Cost after iteration 100 0.672053
... ...
Cost after iteration 2499 0.088439
" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9856459330143539\n" + ] + } + ], + "source": [ + "pred_train = predict(train_x, train_y, parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Train Accuracy\n", + " \n", + " 0.985645933014\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.8\n" + ] + } + ], + "source": [ + "pred_test = predict(test_x, test_y, parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Test Accuracy 0.8
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Congrats! It seems that your 4-layer neural network has better performance (80%) than your 2-layer neural network (72%) on the same test set. \n", + "\n", + "This is pretty good performance for this task. Nice job! \n", + "\n", + "In the next course on \"Improving deep neural networks,\" you'll be able to obtain even higher accuracy by systematically searching for better hyperparameters: learning_rate, layers_dims, or num_iterations, for example. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 6 - Results Analysis\n", + "\n", + "First, take a look at some images the L-layer model labeled incorrectly. This will show a few mislabeled images. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACMYAAADqCAYAAABDNttVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOy9ebQk2X3X+bu559tf7UtXVe+t7tbSsluSLUu2wPIMXjD7agZsGMDAYA5HA8MxBgQ2jJkzYOOdAYzx2MhYAwe8yhbWhmTtUqtbrd6qu2vfXr09X+6ZMX9kvvh9blVE16vusiqr6vs55526FRkZcePG/d0tIr/fkCSJCSGEEEIIIYQQQgghhBBCCCGEEEIIcbtRuNkZEEIIIYQQQgghhBBCCCGEEEIIIYQQ4vcCvRgjhBBCCCGEEEIIIYQQQgghhBBCCCFuS/RijBBCCCGEEEIIIYQQQgghhBBCCCGEuC3RizFCCCGEEEIIIYQQQgghhBBCCCGEEOK2RC/GCCGEEEIIIYQQQgghhBBCCCGEEEKI2xK9GCOEEEIIIYQQQgghhBBCCCGEEEIIIW5L9GLMDSCE8HMhhB8ap98ZQnjuVR7nZ0II/+DG5k6IWw/FlBC3NophIW4siikhJgPFohC3NophISYDxaIQk4FiUYjJQLEoxGSgWLwzuGNejAkhnAghtEIIjRDCxRDCvw8hzNzo8yRJ8j+SJHloB/n57hDCx6/47vcmSfKDNzpPN4oQwntDCL9ws/MhJgPF1K0FO3UhzBTDNwL1i4Iopm4t1C/evigWby0Ui+JKFMOvHY1RxY1AsfjaUSyKG4Fi8bWjWBQ3AsXia0exKG4EisXXzp0ei3fMizFj/mCSJDNm9jVm9hYz+4ErdwghlL7quRLi1kUxJcStjWJYiBuLYkqIyUCxKMStjWJYiMlAsSjEZKBYFGIyUCwKMRkoFsWr5k57McbMzJIkOWtmv2lmrzczCyEkIYS/EUJ4wcxeGG/7jhDCEyGEtRDC74YQ3rj9/RDCm0MIXwghbIYQ/pOZ1fDZu0IIZ/D/IyGE/xJCWAohLIcQfiKE8LCZ/YyZff34rba18b7Rr+VCCH85hHA8hLASQviVEMIhfJaEEL43hPBCCGE1hPCTIYSwk+sPIRRDCN8fQnhxfA2fDyEcGX/2r0IIp0MIG+Pt7xxv/wNm9v1m9qfGef7S9Za7uH1RTIX3hhB+OYTw8+NreDqE8Dg+fziE8JHxtT8dQvhOfPZz43P9+vi7nw4h3PcK56qHEP5FCOFkCGE9hPDxEEJ9/Nn7QwgXxts/FkJ4dLz9r5jZd5nZ3x2Xz6/u5LrEnYNiWP2iuLEoptQvislAsahYFLc2imGNUcVkoFhULIrJQLGoWBSTgWJRsSgmA8WiYvFVkSTJHfFnZifM7N3j9BEze9rMfnD8/8TMPmhmu8ysbqO3zC6Z2dvMrGhmf2H8/aqZVczspJn9bTMrm9kfN7Oemf3Q+FjvMrMz43TRzL5kZj9iZtM2Cqp3jD/7bjP7+BV5/Dkc5/eb2eVxXqpm9uNm9jHsm5jZr5nZgpkdNbMlM/sD48+OmtmamR3NKYu/Y2ZPmdlDZhbM7E1mtnv82Z8zs91mVjKz95jZBTOrjT97r5n9ws2+l/qbjD/FVHSe95pZ28y+bZzH/9PMPjX+rGxmx23U2VTG+dg0s4eQxxUze+s47n7RzH7pFcr9J83sI2Z2eHyut5tZdfzZXzSz2fH1/aiZPZFVFvrTX5Iohq84j/pF/b3mP8VUdJ73mvpF/d2kP8VidB7Fov5uuT/FcHQejVH1d9P+FIvReRSL+rtpf4rF6DyKRf3dtD/FYnQexaL+btqfYjE6j2Lx1dShm52Br9qFjip7Y1yJTprZT5lZffxZYma/H/v+9HYgYdtzZvZNZvaNZnbOzAI++92cYPn6cSUuZeTnWsHy78zs/8JnM+OgvBt5fgc+/2Uz+3s7LIvnzOwP7XDfVTN70zh9RweL/uI/xVR0nvea2X/H/x8xs9Y4/U4bdToFfP4+M3sv8vhv8dm3mdmzOecpmFlrOyavkaeF8TXNX1kW+tNfkiiGM65F/aL+XtOfYio6z3tN/aL+btKfYjE6j2JRf7fcn2L4qmvRGFV/N+VPsXjVtSgW9XdT/hSLV12LYlF/N+VPsXjVtSgW9XdT/hSLV12LYvE6/+40K6U/nCTJQpIkx5Ik+etJkrTw2Wmkj5nZe8bSSmtj+aMjZnZo/Hc2GdeeMSdzznfEzE4mSdJ/FXk9xOMmSdIws2Ub/QJvmwtIN20UUDvhiJm9mPVBCOE9IYRnwkjmes3M5s1sz/VkXNxRKKbyv1sLIx/DQ2Z2OkmSIT4/uZPzjmXQGuO/n7FRLNYsI37Hsmk/PJZN27DRAMFM8SteGcWw50v9orgRKKbyv6t+UXw1USzmf1exKG4FFMOeL41Rxc1Esej5UiyKm4li0fOlWBQ3E8Wi50uxKG4mikXPl2LxOrnTXox5JVj5T5vZPx0H1vbfVJIk7zOz82Z2+AqPr6M5xzxtZkfHC4+vdL4sztkoaM3MLIQwbSPZo7PXupAdcNrMrvKHH3uM/R9m9ifNbDFJkgUzW7eRBNNO8iwEuZNi6lrnPRJCYHt7dCfnTZLknyVJMjP++14bSa61LSN+zezPmtkfMrN326iTu3u8XfErXi13UgyrXxRfDe6kmLrWedUvipuJYtHPq1gUtyJ3UgxrjComGcWiYlFMBopFxaKYDBSLikUxGSgWFYuviF6MyebfmNn3hhDeFkZMhxC+PYQwa2afNLO+mX1fCKEUQvijNvJdz+IzNgquHx4foxZC+IbxZxfN7K4QQiXnu//RzL4nhPBYCKFqZv/MzD6dJMmJG3B9/9bMfjCE8MD4+t4YQthtI9/3vo0loUII/9DM5vC9i2Z29xWLp0LshNs9pl6JT5vZlpn93RBCOYTwLjP7g2b2S9d7oPEven/WzP5lCOFQGP0C9+vH1zNrZh0bvW06ZaPrIxfN7N5XfxniDud2j2H1i+Krze0eU6+E+kUxSSgWFYvi1uZ2j2GNUcWtgmJRsSgmA8WiYlFMBopFxaKYDBSLisWruCMv+lokSfI5M/vLZvYTNvLdOm4jnzBLkqRrZn90/P9VM/tTZvZfco4zsNHi4v1mdsrMzoz3NzP7kJk9bWYXQgiXM777O2b2D8zsP9so4O4zsz+9k/yHEI6Gkax13ttt/9JGPmW/bWYbNvI4q5vZb5nZb5rZ8zaSdmpbLDv1/vG/yyGEL+wkL0KY3RExlcv4+r7TzL7VRr+m/Skz+/NJkjx7vcca87+b2VNm9lkzWzGzf26jtvznbRS3Z83sK2b2qSu+9+/M7JEwkoz7r6/y3OIO5Q6IYfWL4qvKHRBTuahfFJOEYlGxKG5t7oAY1hhV3BIoFhWLYjJQLCoWxWSgWFQsislAsahYzCIkyR2tmCOEEEIIIYQQQgghhBBCCCGEEEIIIW5TpBgjhBBCCCGEEEIIIYQQQgghhBBCCCFuS/RijBBCCCGEEEIIIYQQQgghhBBCCCGEuC3RizFCCCGEEEIIIYQQQgghhBBCCCGEEOK2RC/GCCGEEEIIIYQQQgghhBBCCCGEEEKI2xK9GJNDCOHnQgg/dLPzIYR4dSiGhbixKKaEuHVR/AoxGSgWhbjxKK6EmAwUi0JMBopFISYDxaIQk4FiUVzJHftiTBjxfSGEL4cQtkIIZ0II7w8hvOFm5+1WIITwrhDCmZudD3HncjvGcAjh7hBCEkIo3ey8iDuP2zGmvpqoXxQ3k9sxftUnilsRxaIQN57bMa6+mmiMKm4UisXXhmJR3CgUi68NxaK4USgWXxuKRXGjUCy+Nu7EWLxjX4wxs39lZn/LzL7PzHaZ2YNm9l/N7NtvZqaEEDtGMSzEjUUxJcSti+JXiMlAsSjEjUdxJcRkoFgUYjJQLAoxGSgWhZgMFIviurgjX4wJITxgZn/DzP5MkiQfSpKkkyRJM0mSX0yS5Icz9l8MIfxaCGEphLA6Tt+Fz787hPBSCGEzhPByCOG7xtvvDyF8NISwHkK4HEL4TzvM3/av8v5CCOHU+Lt/H59XQwg/GkI4N/770RBCdfzZu8ZvxL0nhHAphHA+hPA91zjfHwohPBFC2AghvBhC+APj7d8TQnhmfF0vhRD+6nj7tJn9ppkdCiE0xn+HdnJtQtwIJj2Gx999Rwjhd0MIayGE0yGE7x5v//YQwhfH8XY6hPBefO1j43/XxnH19ddfOkJcP5MeU+oXhchn0uN3/F31ieK2R7EoxI1n0uNKY1Rxp6BYvOp8ikVxU1AsXnU+xaK4KSgWrzqfYlHcFBSLV51PsbgD7sgXY8zsm83sTJIkn9nh/gUz+/dmdszMjppZy8x+wiytOD9mZt+aJMmsmb3dzJ4Yf+8Hzey3zWzRzO4ysx/fPuA44P7eNc77DjN7aJzffxhCeHi8/e+b2deZ2WNm9iYze6uZ/QC+d8DM5s3ssJn9JTP7yRDCYtYJQghvNbOfN7O/Y2YLZvaNZnZi/PElM/sOM5szs+8xsx8JIXxNkiRbZvatZnYuSZKZ8d+5a1yLEDeSiY7hEMJRG3UoP25me20Uq9vH3DKzP2+jePt2M/trIYQ/PP7sG8f/Lozj6pM7vD4hXisTHVNA/aIQVzPR8as+UdxBKBaFuPFMdFwBjVHF7Y5i0fOhWBQ3E8Wi50OxKG4mikXPh2JR3EwUi54PxeIOuVN9wneb2fmd7pwkybKZ/eft/4cQ/qmZfRi7DM3s9SGEU0mSnMexezYKsENJkpwxs4/jmN+xg1P/4yRJWmb2pRDCl2wUGM+Y2XeZ2d9MkuTSOD//2Mz+tZn9A5z3nyRJ0jez3wghNGwUdJ/KOMdfMrOfTZLkg+P/n0Uefx37fTSE8Ntm9k4z+8IO8i7E7yWTHsPfZWb/PUmS943/vzz+syRJPoL9ngwhvM/MvslG8m5C3CwmPaa2Ub8oxNVMevyqTxR3CopFIW48kx5X22iMKm53FIuOYlHcTBSLjmJR3EwUi45iUdxMFIuOYnGH3KmKMctmdnCnO4cQpkII/zqEcDKEsGEjOemFEEJx/EbVnzKz7zWz8yGEXw8hvG781b9rZsHMPhNCeDqE8BevM58XkG6a2cw4fcjMTuKzk+Nt2yyPAyX6bgjhaHA5pMb4syNm9mLOdX9rCOFTIYSVEMKamX2bme25zmsQ4veCSY/hV4qrt4UQPhxGcm3r4/MqrsTNZtJjahv1i0JczaTHr/pEcaegWBTixjPpcbWNxqjidkexqFgUk4FiUbEoJgPFomJRTAaKRcXidXOnvhjzO2Z2Vwjh8R3u/x4bvYX1tiRJ5szlpIOZWZIkv5UkybfYKACfNbN/M95+IUmSv5wkySEz+6tm9lMhhPtvQP7P2ejttG2Ojre9IkmSnIIc0nbgnTaz+67cN4x8zP6zmf3fZrY/SZIFM/sNG1+zmSWvIf9CvFYmPYYz42rMfzSzXzGzI0mSzJvZz5jiStx8Jj2mroX6RXEnM+nxqz5R3CkoFoW48Ux6XF0LjVHF7YJiUbEoJgPFomJRTAaKRcWimAwUi4rF6+aOfDEmSZIXzOynzOx9IYR3hRAqIYRaCOFPh2wvsFkbeY2thRB2mdk/2v4ghLA/hPCdYeQ/1jGzhpkNxp/9iRDCXeNdV21UwQY34BLeZ2Y/EELYG0LYY2b/0Mx+4VUe69+Z2feEEL45hFAIIRwevwVXMbOqmS2ZWT+E8K1m9j/hexfNbHcIYf7VX4YQr45bIIZ/0czeHUL4kyGEUghhdwjhMeRlJUmSdhj5/v1ZfG/JRnJt9+6sJIS4MdwCMXUt1C+KO5ZbIH7VJ4o7AsWiEDeeWyCuroXGqOK2QLEYoVgUNw3FYoRiUdw0FIsRikVx01AsRigWd8gd+WLMmO8zs58ws580szUbSQz9ETP71Yx9f9TM6mZ22UbeXR/AZwUbvWV2zsxWbOTF/tfHn73FzD4dRlJGv2JmfytJkpfNzEIIvxlC+P5XmfcfMrPPmdmTZvaUjXzAfujVHChJks+Y2feY2Y+Y2bqZfdTMjiVJsmmjMvplGwX6nx1fw/b3nrVR0L4UQlgLIRy68thC/B4zsTGcJMkpG8mRvWd8zCds5Bto42P/kxDCpo06ul/G95pm9k/N7BPjuPq6nRaGEDeAiY2pHaB+UdzpTGz8qk8UdxiKRSFuPBMbVztAY1RxO6FYNMWimAgUi6ZYFBOBYtEUi2IiUCyaYvF6CElyx6nkCCGEEEIIIYQQQgghhBBCCCGEEEKIO4A7WTFGCCGEEEIIIYQQQgghhBBCCCGEEELcxujFGCGEEEIIIYQQQgghhBBCCCGEEEIIcVuiF2OEEEIIIYQQQgghhBBCCCGEEEIIIcRtiV6MEUIIIYQQQgghhBBCCCGEEEIIIYQQtyV6MUYIIYQQQgghhBBCCCGEEEIIIYQQQtyWlF7pw8NvPZZsp4tlf4emWPR0oZxgezFNV4sVT5c93R/003S33/Ptw0GaTgrBM+GHt3arlaZXziz79qW277R9+ODHqFWqaXpxfjZN16u+fbWz4scz4scZIO8D5jfxTAbkNyAPhZKXWeJftUqtnKan5n2fQcGvddisp+mSTXu66LeviHSp5Mcsl5n26y0X+F3PZ4n3FvehP/Rr32w10nQ3aabpY29cNDOz+n0osxn/fP+xqTQ9t3eYpqdqfn27Fh5K0+2B56VanUnTe2cX0/RC3bcvtzfSdGvgeWx3u2m61PHyCC3P5+nTXp9+5Pf9B1TAiSG5vl1uzCUM119O06tPfzZNXzp7MU13t9bSdL+9laYHg95VWSmibhbRLhQqtTRdm/Z7OoN4rda9ntTrXpeq9zzmx5w7gtzfnNuY8D4MvY3bOPWJNL11/HfT9Bc/93SafvbFc2n6+Cmvkwd3zafpzpaX8VTJr7FS9PNWS6P4ruDzXtdjuLPlcRmaHiubbd/nnX/uu9L0N/+1f+7XFLztSMxjy8yv1RJPh+6mby/5fR4W/N6GoefHOmd9+9QbJi4Wl5aW0oIe9L0xDwVvr4ZDb9/YDyQJtxvS2d8t4JiDgW8vlYqZ+7MPZr90I2De82KL15p/HPSXUdn4Pp2u93+F4NfEPozHQTFF5VQo+HfNsu/JzvKZd3/CNfffzk98rdllwEIIhew89nF9na6PVjjOifHjFFEeAw5EsE+Itvr/DhzcN3Gx+Av/63RaYN2+lznHPbUKvsD4Q1k3h14uBYyNpssY5/U6abrT94N2hl4sTd/FChgzsZ7MVEfnTXAfGx3ft9f3vITA8TXuY/DvrqDpLOCaKmGQub2EY/YQ0htoysuYGSxOYzviDN1NdJxW3/O54l2VVdAvDljfkLdaiXnzfZifOk5ciMbbnjaUdwvVvDvev2DZcdbv+/ZWB+N3r04268OQiA7Kr4NJRLfrx1ztYqzNskTehyiPIdsMlPGPf7I/cbH4/e/5X9KMT097P1+f8napirgMiLPFXQtp+uAu/+5s3S86HU+a2ebKapp++dkX0/TyufOeoQT1p8L2wGM3jOc7XdSR2l4fQ5YqfrPPvviVND1f4ViLfUzITJZw3eyjWX/77M+i+47M5fRDA6R7vJY9x9L0rgN+XeunnvLvtn38lwzZxzsFXEwBc8Riye/h0Jh/fBn3YTDAeGlcDgXMXQOO0e9lj63KZd4/jHd47JI3WtXd96XpX/3QZ9L0Bz7i4/GNTZ875o2bAq57fn53mj5/9szExeKFA6hZXOVho81Gh/tE7WhOmscp5R2H25PMzTxmsp2fYnbbnDDMeH5WNqa5GMPvIo8Jd+c+udeNNK+D18085Jw3/7tcS9rJtefkk2meq5hTPtubr/d43M6wQX5ZrkneT/Hypip55+Iu2L7/Lw0mLhbPLg0yr44Z7Q188NBq+4Cu0fJ26fhLX0zTm5uX0/SBvQ+m6VLV270FrJMdOXS3n4xrql0/VweDlsp4LlHH8aI+CXnnuijnI0PML6pl79NL6DM4v93J6tUAg6BCyK4QUdxEB9pJJXOWVi+k6c899eE03W35IP/iZV83PogyfviB1/v+KNe7Dnh/zLbtmdNfTtMnnn3CzMy+/ZFvTLd9vudlvHz+iTTdKu5N05UDj+LYvv/UwAfh1a7Xm+7yiTTd2fQ1mkHfxypDzqWr2F7F3KnpdWgG45y/+d1/e+Ji8b9/7HNpxvfsmku3Hz/v93Gz6/VqL9bd5ip+358Yenn98WN3p+n3/9J/SdOHD+xP02959N40/eXjJ9J0v+Bj4zNnfO3v7Elfd+1t1x/M3RsYsHaxHse1j9D0axp2vA4UZ/yaDhw8mKYXF31M89B996fpPbt8+8LivjTdanm9fvm4199e18vp3vt8PX//fi+Pdtu/W8e6bjQeSLwO16a8HZqa9nXDGp4dlNG35a21tNrezl5e8bb1d37rA2l6q+l5a5x90szMjixgvj3w8vhjf/F/8wwX/V7+81/w9d0pzB3f9ebDafrCitehUgnrCRj3vnhmPU0f3ufr4pfXfH3s3W+9K02XK9nrgm975KGJi8Wj9xxKbwzH1oGVIPCe5g1CMDfJ6aOiZ3Hoc/K2c92wkLF+yzX+kDcIiuZz2XkfZgzBriKaUmZfd7KTtUVQDCwD3872ns84uSYRHRFf5tpiIbqfToILjtaTWWyGNTfU4e3r4vfiuRrrCrOINRfM1eszHq/7H/B9jrwe88ih77Nxyccw/TVfrygPvT2toP/rJx7frf5Lafp9P/vZiYvFNzz2Bu8XD+5Kt/d7vubSbHqb00Ibz2f6SfRc/NoTBcZFEfH39Y+/KU3X8Cz8gx/1MfDsrvHYB/MY1oY+ns1wjFrks2+ORbEOEb2CkFPHuD0eWWav5ydRHed2pFF+rMOPvcHHdv/o7/8937/n3/3yk59L07/4/l9J0x/4wEfSdK3iZfxnvuPdafqTn/mCH+dFf/62a6/X7al5Hy+l7Q3XpnJIQva4O26asp8/RG1Ezng/b82NbWUSHd/TL3zpmcxYlGKMEEIIIYQQQgghhBBCCCGEEEIIIYS4LXlFxZjalKsy8G2ugF+1JAV/Y6hSyv5JTBdva/WhJNBNqDbAb/LXu37eqWl/a3iw38/bw68nCsNRHmZm/e3axRmm/W1jwxvJ68uuemHD7Dfd+Jal5ajH8NevfButiJ+HDvFmc7WOX1NWfZ81vJ1XGrLss3/GE0LOW7D8tTjfnOSv/vCrO24f4hf2/KXGEOlu29Nnnh69gX205m+Wle/x3DY2/C3D8pSfc3bK30oLqJIlXt+QZe/p0hBqOj3/5cIW1DGGeHOxizfsBn3fZ34BP4u+pcAbe0PEU6GGfV79C6qh5PUzUorCIXt91A28pVnI+IVOsOxfAA96uKdQ+Om3oTyCn233e/4LiOEpV1yp34c2q+5v9u+sDHaisIG2b+Ax2m/hlzhbS2m6vem/bP7kr/5Smh5sentz9qL/cmF5NfvXu0P8Yojl2sV2iAikv54I+DVJrYY3Yof+C4XNppf9JqrTwhEEb/Rzymzit+jjT9LUDoo45LxhOilEbxDn/CKN/dYwUubILouQ80sH/i/kvsV87e3ZXFu5ZUDVi5w3c/NiK++XC7HiCn/h4vuX8QuanVxSXJbRJzn5zH7zO3/7tc/L/AcE43BchgHXGr0VHR8RB8w+J6+Panx5+0QKFMOce57zBntOFiaGDhQ4putoo9BBsc8pYuw6wDhzccbjtdvz70KcywoJf13g+7ShPJdg7JigzawVMQYej18aTW8XOlCsqSCPQ7SFJYxj2jgPxGZsvoQ7hntdyPklE8uPP/xfxPChiu0D/uIHZczfRGPoalM8L66lnPMLJMZToYx7C4WOAsqhmBPfWxwWYY/tQ3Ioj2lA9GvjMi58Cr+QrfC7ODbvFX9ysIVjVnCxFSr3IL+FSMHRt7cmPBirVdThiscK54WRcgrSVSi6VMrZdZVqIqWqj/tn97kSSqcL5ZSGj6sYC1TKqo37mQLUQ8tVqIpivlie9nnKxoaP8fbP+3cDFRnYlFOpCqIGPcxB4rldTl/Ldo1KR1AlapuXzZ7d/mtSw6+TA9om/tIvyVA6G10KVTyg3lJlP51k749jFgZUvwlXfT6k6guurxApmWaPRYtVH/tXZv26lxo+h3j+pZNpuodfw+X1x1G/iLy12DFMIjtR+MhTP8nbJ9oesrdHCiwoO4ZF3vG3m4kdqZbknf86VWKiXyRnj+tz88tJcJnbd5Cmoko0LMX4IVKJYTqnbci7VzvYZ/tXdLnXGhj/yCP354/7cssv79eDOfOfnHsS3Z+J+/1tTKPtvxzuQlFlGmrHbSg6cAy5suoqEqvr5zL3KaPvWphzlRgqs2xBFazZ9Pysb/i6xeK8q0Fsi79SASZad4Dad7mIvhuqlX2o4MTqad6n5s19OGdpIu9URqMKTaSYXXzFZe0M/FyX11wJ+fxl7yvWVi+l6eMvP5+m6xX/5fiFC64wc+rU8TR96KCPT9a6vu5z4rwf5+LSqTRd2Rytkz530JXwtlq+jhS6Xh4HoKhX3fCBd8DAsY1fd2+s+3G6G14PdnG9/JD/YryFPu/imqtXdKDePo/6VwzXW/ZfXR5/zBVM1hp+DVsn/N4dgpLMwV1QGsRa6P0XoDDXhkwoxjL1GlWw/ZhH7nkgTX/mM/4r76XzZ9I051Nhdo+ZmZ2/5LG6ifXDvYs+Ln3oqCvAnD3j+fp9r3fFmkHD25qf/sTn03S15kG6f9FjdH7Wj881yeVlz8+JkyfS9H33+rnYrq+tuQJ2Bes7fSgUUTmEjUOkdl3yticJGH/S1QB91KUlH6v/v7/0a74dak9rS640Oex7uc2Ph9IP7sd8ZtPj4Myp02l6N9SgDkH1ks8ZXj7r59wzj+dZ6CTLmCTOT/n11fAMac+cl9n5Sx7HRw6ibZ3sZdRIMT5+fsU6kNe5Z2+PjpPzzcIOnpVRBSbJGnjkqMHEaiZUX2EOctYbuXUHygfREZPsOTPVGqL120J2X8u1Waq75K3nh+h6qRbC54jZ648kWvJnnjk+335OGfh8GGsOmItO45lvBf1TicqxdY/RGbh1FMz7guqs9+l1Wy0AACAASURBVLWh6GOhDstvnSrteC4NJwUr+nEmkQpUu1otKl3DtaPufZiVfGy3hXWWYfDy5XctJ76ZpvrX/Lz3OefPuILJgcP+TOrh17/VzOLn14zny5e93T97ztvpXbtcZe+uw75OwLFryFEniRSMLDtuWMeZpmpNtP+AyjZIY583Pnp3mq6iXNebXsca694PNOAI0Uf/U5n2NZJzF718zi15v1Stw8VmzseCAX32dhszpLqTfxq9B8GJYaQolDfni9oUHJNqqjkrNiFnDhFy2tk8pBgjhBBCCCGEEEIIIYQQQgghhBBCCCFuS/RijBBCCCGEEEIIIYQQQgghhBBCCCGEuC15Rd3DahUSdwXflTJflMvcXXdpOEpHr7V9H0o4Ux55mGPVQwkc7j+/yyUsB0ddHGc6jKTkFuf882lIa1aR+Q3IEQ4oo1akvBr0ZIvUv6XfBDZDwq8GmyRKl/F9pFI1x16B0muUBKJaOyWqWa7RdsjO58hw5yl4UwKNsk60jopk5LqjPGwe94MsTrk8VqfmUmRbZc9vawaS6lMu+1QruOxTH+dsQt51veiykO2up7st5BEXWAuen63E5aZKhQnXqY9AJei7rGMy8HIJ1QPY/zVoDRchMQ8pxxItkSDVRdms7XpSovRyZEGGModkYr/jUpbdsl8TLbGYbm+5TN1M1+VRFx5+p19GZKuE0w79XCy/HqRrt5Zdhq0HWd/LZ1wu98yLnl5ecsnQXsuPf+KkSyGXEMhV2A5sYX9K2XchhzuEBPwAEqMN3IfG2BdjZspjaxrtUYJjI1SsjXZ+CpJz10+2TcvOhMwmG8rdxc43sGxBn0OZS7ZFXViGVSu0FILVUI6F1fVZJmV/b4g2tVSiFjzsAFEfOpAEr1RdqjLPMikPnjfkyZAa228OU/LqEq2akP9izu7cnGPDFF9XttVQnr77MOpOrn7/eCfHyMtwJCPIzjtbTfWKL9PugsekdOyt0xfWYD9ZopQyxooM1z7qUgXKkENoV4eht69FWIWuwXKu26HcI60u/Ziz5WzpzE5vlO7AUoUupNH4DTeSdpabbd9nBtLS7JepWkv3hV4fFkio8LvmYV2E5iCgAOkKR/ufNSjFlnHiCqwT+jn5ocxwH/G6UPMPygwLlDFbhg7H4TjXFENkfEjaO/RQxhyrwCHAaqgrHMqzbtGKqoPj0O2sjC/H1qawKch2w5r4XzF0IClfgpQ/55GMyzokjmu4wWVOszh2HGa3ezN73AKiUPZjrp5yq4LOpsv9lmgdWx7VoCG+V4BlZxnbd+/zMfVzS265UId32OyMz1k49xr2YPGEcSbHA2XaLyKOo/4vksz247dgLzsD64bKlMsf9zE2LsKGYoD80C6oiH6GY57IMilnbDPM24cd8nhzEo0H/ONSOdtLJlJXx/ioPL3fN0/5eP+Ln/ndNH3uot83ShvnXVMe8ZxnAoksfHIakeu2T8pLZ0u078RGKNOSie11noNrnq1S+drnZ5vCvESWP4WMfJnFHQ6PmXuc7GzmNeZJ3lAwL8385Flj5VosXW3blH8dHB/mdOS0WM/zBcgpmyji8q4jb8h8bZffm8rzLz6RptfW3ZJnGhbig4GvRd195E1pumA+eGhs+j7tjs8dZ2e8TWu0fT1oEzZJjz709jS9dNnXIbgmuDJ0C4HtfFbLsCrHgLmEdaHFxT1pmraUJ089m6bXG77W+uB9fn17d7n1S4t2Ty3vr1dW/foqZc47vY+ch4XUHhxzJ/PRPmyhPvfUh9P08ZPPpOkh1lnaW96PJgMvn9270P/A+nO96GtJF064LcAQVkb3LvpaS/XAaB391CauGwG1f9GvtYB1hh7mzKsbXg+2cJ6AMdreXX6cqXkfJ6xh/W15HXYQGAPsmeZ9gF1OE/ZZE8j/8x/en6Z37/J6O+x5+S6t+Tpy67xbDMzP+ZhpX93LfXDJ79P9aI93wR5t5ZzHfbnsY8QH7r0/TRcRa5/44pdxrrHNHeaQ3SHWDGFDP8SYpl72ffbN+jkP7PV25/DTbuH18rrHXwGWWJcveZ3ttr0NevaZr6Tpp578Upr+2Mc+mqZnYGnytse/Nk1/87v/Zz8XLaYRrpuwg3jy059O03v2+zj8scffkaZ7mEhiSdU++gm3q/rkJz6epgeI+4CGq9P2+F4bz62fr7ilxMKsP+c6e97b2MPH/F5+7T2+zwvPPJWmi2tezx66y9vBHuZCoebpffOYq1Syn8HRCjX29qWF++RRCLjmQvaAaDjMXovayZpjtDWyzKQVD56D5dinxBaR4304rksyPjezPq1oc/IbnTJyjbx2viK7Wk4L450cjs9oCUMLpBwrpZhsOxmWJc/LOV+1ivU3WvChDtemvK2qweKnvL2QwjUaLJzVYKVUxNyx3fX+rz/EQlXw7QlshqM6F7w/K2A9D64/VujBErPnbUehjTm8TXYs/v5v+cNpulbxi6tWvc8r4fnf0mXvzz77+U+l6S202aHAOMu2QmbdnpmGPfaM38vnm37Mhx/+hjT9Te/8xlEiWo/ze/TSyy+l6W7X2/q7j8GO6SG3NeTaFC3LoiUXWiDxnYVhdjrPGim2T8peJ+bzvwfu8TFtc8vHxsur/qxxC9fY719tWT2+gjT1wosvp+lNPHdc3OvraTOLns6ylxrkWEtF0zN8r5jTzg/Q1vCdkn6PNpXZz8iGAzwP5YsT6P/4zIntXR6TvtYqhBBCCCGEEEIIIYQQQgghhBBCCCHEq0IvxgghhBBCCCGEEEIIIYQQQgghhBBCiNuSV7RSGkL+qRjJV1FX3CWoNmDxQf2hYYBsELU2I5sf2DbhfZ1BjhxcueL77z/sEpaL5ZHkXS3450NKX0JiqNuDhBG0f2I7BdpmRFpnnndIFpYhdzc149JQtHcolyKd+jTZG3o+KSA3xOtLRciSlSkJDunyUKSEFWUKc+TqKPOWI5MWSSahGKqQ5K5vS3B1/PqaL3pBzSz4tTY2IF256fVm8e1+vOn6bJpeG8AyqQPLm4FLXdLuojT066YkVWfg0kzTRT/+Zt/lTiedJIG8VPciPkG9ypMdvl5KkDuE1FiBcYEYpYRXcXsfSsrj8wHfy6PdBSSzeqjLQ9zHQSRv5l9ubfh9bG65nOz0gbtwHI/7lfMn0/Tq8pJvX/L0pQue7kDCuN1EPUTb12j4dlpbbGz5fSvDOqEIOeoq5Oq6BcoUwlYCliE9tpXQvt6WGW7gnJ2O57GAAlxvwjoE7UgCqdGdVaIcm5YcKbdb1VYptiCqZG6nrGQCPXhKZLIfoNQmrR4i2U1Kn+9ESjRjf0oa7kRmmv3fMKf/SyLfv2u/a0vbpjgPtN+C/Qb3ifVRM4+fJ5vHc8X94vVZGXF7XhHymNtdJ2UEKbEYouvOPnau3VMk85pTP3LKKdA+wrLrU2EHdeRmwnFpLEPp+7A/qVVZRt4PbG1RyhHlgv6q0WIsIo5wnGnLjoV+wceC7bFUZCGgTUcfUGTM4WitPvfxT+Yg206LwT7uKZ0/2qhLe/e4bO2egz6OHkIStnv5vF8RygbK/oYsWL2c3U4wnDjx4Ph213S2pU4x6lBo9eabOVOYwQk4LtwehnP80MfgH64/Nu1q2JbA9ooSw0mOowoU662CPBYqjC1cB/IAJy9rQeK9OuE/Y+jDW6uFsVG95mN6xk0Z86Z6he1VthTtEJW4wPYK5VKbc8nzOiwe+i2vrElkCztK0/qQtsHsJ+Zgz1uuedycXnI59aORlDbmT2hHpuu0pPDj9xEsXVgvDWhRhT6kg/JuBJdzPrLPZXeLZa/QnSakow2wH2DDifyUIFnN8Wof8r3cJ+qyKaMcWUyO/qWMbsiR4y6WOQ/x+lSsuQVEEVZKz77k9qef+YJbmdDuaxjJACO/SNPahv1on0E6iZR2YGmUZ+1z3fvg/lHVP7JEy94eWS9tnyvH6ijfHmgH15p3zNIO9sk7To5tU2T/lmNd2W36Puc3PH3BVbJtC33LLvRF9x329Ow8Rgh518V0Tn3eri/RvUFflVsGsWY2/sOyydP5z8tjzvghjwm3UvrS027fUcN6Ci0GVtfd0uTUmRfS9MH9D6fpuVm3vtlqnUjTL55yy5+NLbc9mYG1/cy094V75ty2pwXrpYsrbrHU7Y/671NbLtVeq/nxFucOpekBxqtTU94P0Ya3UvQ+76WTz6XpKmT7L+P8l2D3VC55e99u+VoMrf4qmIe3pmAJg/6GFgGEbXm94muCly96WS6v+DEPHfL+tTrleev0fRwwk/j2/rKPPQZrnr7n2N2ef1jONJqjtc5Z9N1zHIzimrZge3R51ddC27A0mMZ92LfP730B1hMrDR8bbMB2so65+sKcW/B0MUw4ccnr0Asvez2eRGYLfl92VTwWKxiLFvve2B272+v5wm6/B90VrDOe8jXEe2pef3orfg+6fV+nLWD9cR32ZCvrXo5vf+yRND1VHbUTL511+4pK0dv9Ut/v13TZ728fliSfWPK8zM75mGmF8w5zirjvzQYtlnyfGtYhj8NKfg32W7RLXVvxtuTB1/n1PfyIj6u5bvHpT30yTf/YT/xYmv62P/FX0vT50uOefwzWisHL+LNPebkd3u9taB/tLy1berBNm+uN2qFiweMsIP4uLXvc9DDG31jyONh4+nfS9IH73T5p6lm3y+o+8qinMT/4yid+y8+L5yGve/Nb0/Q07nOx5fP2ymkfA9sb/fiTAutboO0Q59c561I7sTst5Fh4xEPE7PlGvhf51R9HNqzYh3NdOojEa7rZxwmRLzpLKs8OKXtdPVpbzLkmbmc5RW0i5nYl9EtVxHcF/UkNc/46+i7O+SNbXUwcivCe5rm2n//QwoZzTi7GNNo+Tlhve/vcGXgbRMv4TsnzmMBtqVBBvtqer+mWt6HVgsflcoJ1M1i8JJ3Jftbxtsff4v+J1n9pj+zt2/yCX/PLJ9yyqN/3tjbvOIUciyXaaXW63l9tNb3tnZn1MUhl3HfGVsx8rsZzMs13GZDms0b2i3yeELJjK1onj5790J7JsB3P9nImuSXMpxbnvH9qNv1ZeLcLW27GRY5lEZuA9U0/TgFxNrvL7ZOidz0yCAWuofB5Jcf+eCcC62ZlnJOlE6/j830RWkb6Pv3IlgrPoof+3X6f6WvbfU74UqsQQgghhBBCCCGEEEIIIYQQQgghhBCvDr0YI4QQQgghhBBCCCGEEEIIIYQQQgghbkte0UqpBPlL2ioVII06VXEJqnafMsVJ5v6U8onksBPKi8EiqMjvUsbI3+kpQe6qsC0J23IZqwEkp2mj0oHUldF+KLJBcMmeAFkkWhcVIMc0O+PlMT/t8pgd2DZVIFM4gNxPs+vnohQR5ZtiSWvIkkXa1SjLHOuMSGkJkv60t+E9pLptDfZJVcieVcZpSlX1G5BIuuT5bbuKkzWecSnIhx+A7OcDLo29teXShO22SyElBU9PlSE3CjnMAeS+ab2wf3p3mg7NHE38SWQIWccuLKAg6Wa0Osqx0NoJAZZksfURyhQx1Wi6lFx5bBMGVyvrok4NISEWCn48ymSVGYuwK6IMX7fn5dHuevrE6TNputVzWc52z+tMH8ekZFuj5RJlWy34IkBWrYvvUs5tfdO/W6Q1Ga12aJnU8fJrwaqpgnaFUmCxuwnaWdpHjKXgaBdHqc8BtHBLqCsLUDfrNKEpmC82b9fmOu2TknDtfW4i7J+u+CRN0b6NVkOJsT1mXGb3c4RygHH/yu2DzO3XOnbePn3EOa+b1hA9SNPVazm67bnnwt60p8mRAN2ZhCrblewy5jvB8fH9Xg2jsQrzw7Rlbo+tppKr9s2zNbSo7GH1GMmd5vT7SbaVpbENH1CW1YmspV6T995Xl04f96uH9hL3olanVQisgFpoD/u+vd327641/T7RIqgEqeaovDCWKlZd9nMKktmlyqg/aW15+0r7pMjqhVKcqJAzZcR5jrMBZUXXUR579ros56G7j6XpLvq5Fu31cFAMvXipNkMrnJz8lPGfITK9Cwr3NXom0Uolx0YD3ZtVqMwJhhn9Cbt0qPvaLIZQVVhJ9GBt0/PuPRoXb3ayLZlYHri1hmGpDSPbUt9ON4vihIfl9DQkvSFjW8RYZ4D2NcDCoEDrXdhWFSiHS4tBSKYmsEdNzKWdpxbcPqK56jYHCcaI2/K5UXOJ+WoPY8VNeId1u77PiYsup95oeYWkXdcm5hdz07AFQhyUMbdrYS5IyfqFaa9Ym20vg31HXf62VPaAKmOuVqvC0qoK6fi+T8ai+WI0lsB8t8g2ifPjNBn3nYWoVbo6CRtljlkoeUuZ5VLdpfdrc25rceay34ePfvzTaXplzbcPcuyTYiiRnL39WlLrN53ICmgnFkE56WJOmtLwVDPPOU6S913uM05HQxp8LWoACzmdA/uPPBso7sOyyb3unPLLs3liFUffc/y0p3/m877P/7jgdXKljX4G/UAdc8G33+Un/lvf6OnXP4BY9FC/wi7Kk1G3uH2N7KTzLBHZz+YtLeSVZZIdQ0lOfcpxprylXHgbG26R0kbb2R/4QKIPSfRKcCuS3oKvp1BCfXXNLQHKJRwH/dUK7AOPH/cK1zvqNibnL7mt0caWryVVyqO+fBn2RvW6j2d7+7wPvfeo2z1x/y1Y983CvqmJfHHsPAUbmgsX3MaoBMubctHTh/a6PfbsrFsovnz6+TS9a97HAHv3uAfZ0qpb2zz30hfT9MqaWzAcuevBND29y+/h7gO+bjgNqfkEA7oq2ow5WDhVjvqa8Hrb7+3Wph9/19RoHXNqytczMT2xZVgmra75PQuYk++e9rJcXIR9DMLv8obXsxbuyTTGCeWCl/dlrGudW/W5y+lLXmZdWCBMIp0XnkzTjYbXn8Uj96bpyqKPpTZZ8A2su8Iat3CXx1PlKOwYLnj5bp274Puve91+puHr2kstXwffPftAmt6uV48e9LqzturlXKt5XlZhjzDA+K3c8WMvFv043/YWz/sHP/+VNM3nFbWa79/uYM6MtpyWJxubXjf4rKMFm5/PfvpTafr1b3jMzwtrsM9/6sN+3qbnv421ywvLsA7i8jQGoOvr3g7NYD1r9z2v82Mu+30IWMOqV0cxWO57ecPpyJ4+5/f4U0+4pciDh46k6a9UvN3cuOC2Ls033+d5Z9u+6THdOf0lT895+zUYfE2aLqFca095W1Y6722x/dHvtEmD6/zxmna27VEEn3Hxmzk24Jw/WI51esizRMpYm6Wdj+UMk+LsctyTbRsVf4F54bPRbKuVgOujRUkZz+dCjk1Sbcrbj1rd5/AV9AO0mWGsc3vIeQbJUulj7s25XsAx+Ww3oHy2z0VbxgTrZutNt/FZbvoYYKvvbS+PXcez6wTPt9sbXjYNDEyrqx6jc1u+fX4/bBAbPq7oo78orU32gJW2UiEasGfH6BT6nJlZPHe9yOcetJTNjgyO/6pV2HWhbreaXHS8ehKQ5NiORdZrkT03Fg3zwi+yTMLuSdwyZO+Ud8zstinJeT5WhZf8HN4r4HN/Pr+M7JnYNjCbmO+uw+58et7XVKp1r8/Rc6monLfPOcjYM36O0sc4pDfwe8l2imtEfH5TiGypcALMo8p4wMznYnxmMsR7FoMBJ8fZSDFGCCGEEEIIIYQQQgghhBBCCCGEEELclujFGCGEEEIIIYQQQgghhBBCCCGEEEIIcVvyilZK9RokkoySVr61WqJEGaSaIWPTG4bM9JA2I8nVMj1mZuWiy+10+7QWoOSsf6HRHcldTXf8e8mAkvmepk0E5cEo8x4gvVyGbGYJUj4VWDntW4AkEWTMtqBBHyIrBlgm4ZrqZZc5gimOFSC3TVmkbJOIK2T2qeaWp3oGKHNVhiRiveD3mZZS29B+aoiyb7wEuaShH69PW5cXfZ8HH3V5y6WGS8ee67hkGjNfhkRWD/Y0vbanp+peOu0uLHVyLCYmEtokwUbIILFlQ+j9F3I8BnYCbDuGkLHt0QcA5T7owqpsbK1Gq4JBjhxWwHlYH9uowCVcX7Xm19RrwwKp4ZKXW01PbzRcbnJly8uGUmC0RmLdaMB3IbK5QN0uoC1b2/L9B2izaAu3awoSh6ifbdi+1SGl1uzA0gbtBO3oFuqULR3t30OBN9uwx8D3DtVQxjj25rrLhOZbKe2EyG8m55i3DrlWVrSQ68MmIsfOh9KWw0H2dtpv5b3HyvwwD5GU4Ljcs7ZdmeY+bL8JLf3YB1BuL+pf0Y/HebDM7RE50vRJjn4hbTxyZVOjPHAfxlZ2fng/Wd6RvCqPOJbxK5XYDmeXd6zyCIlASBDykmgN2KcFCa0vmF9KUebYROS5R0wizY6XYws64XWqJSKGoB5pPdih9HqeXtmiZRLim7eX9wD1rdX3ezyHcp8JHguVsTR8AfWFtnW0T6KM71yVXiWUG6b1Eq4J93p+0Qvk4BGXEC9CtrIP+5Ye+jyo8xu6SJv34YChq4qdO1BZ6VY5janFdIXXhe9Gdp+ejEwvMZ+A20Rs2ZqwDxztxCZ5BlZOc64kbB2UB7XsBz1eE+If85Ap2FBQLZnK7GVkGMOmuM7l2XVMINPTXpCcTzFdRsHXi6i3kFgelrxi8T4lUftK6V/OIzFOgoVTAX1Uv311O12te97ruI4uxmPrGA91MP7F9MWOw1YptkbynS41/GZvYqxYg0Z7FYPmOdonoc2an/MgqlW9zJaW3TbqQNm312qe7iNvgxxZ38jOEG1oQvsn+JdFfTnjGP3eMEOOl58XKJONeUsoom7V3TajhzWHz3/hE2n6xBm3K+hhDB5ZKSHDHM9UYd3RQb2MxkvDCZ8vFqNBE9LYp5C9T5JjL5QzlMq1T4ptipLMfaLvjvOcZ7uUa5+Ud/5ooIR6je9G54dFQmQXxOvOWTGL3fowllj2D977Md/+ofNYy8o+ZEQbcf8bL3v65IYX1g9/h1/M174eR41slfLsqMb/0j4pzxW1nF2ueXZSUZr7c5eQ8x82F5FyOT7InqJMDOWSt9ObDe9DCsHXJ6YwYJ2dO5Cmt2CxUS1jcEIbalgSHt7j9uMnLro9yPlVt5U2zMU6HV8X2Wz4uYbJKJ89WJusLJ/3zwde11Y23NpnDemXTz7jeSz69b3hdW9L08trbvcxBzukA/vvTtOnzrpFycKc530JljR3De9J02WMH5odL+OXTj+bpj/66V9L042WW5ccOOT2JtMHPT9z5uu6AXbXfdiYzMGGYteC2y11EOFLK943l9Cf7J1zu6NtC4sWJoMXL7td0ea657eG8fuBPW5XVcMAu4u42YB9Ux/y8nMzc2l6q+X5Pb3k5y1Ucc/XYeVlXh5HjnrdnUSeP/5imq4/5zZixf5vp+kKxhq7j9yfpu9/2+Npeu6AX2cHVg+9NdhnwIl8Zs6trSoHXp+mN5/5eJo+fgqxAHuTtz48Wgd//F6ft033vD4+BwvJY/u83t0zi/YCzz2ea3u9m0U9OTDvdeDsWY/1/bv9XLTqvnTJbUOaTVpowZYY46cKJolrq8tIwzoO9pmbq26BMqCl9xATUmyfMS8HG2JdvOvH78MHt4A1lVYDtsYY/xXHc9NqCde06cdrDt0C7eLzT6fpr5nx8z/6ujek6Zee/Wya/jxslXZjceHUFz+Sphuw7Hr08W9K04sL3jZxfWMVXsBnN3xA46Zwk0O8mom1K4zPinmW59FaHo5JuxKOP2PPc09GlkVZuYnnndvnDdFkJ3vOlLeQVsSklnOfCuy2uaZES6NKzdNVzPl4nDr6Ic5rGLvFyKKY65lYe8qwrRkls+2TovLLGc8F2vRhTh74XJP3B+vP25YsXfRh67AuWusdT9PNobeltGCuB2+356fc4qxUw3i54O1Ie937yOJlPFtqedzP7ObzIW+PhnhmM9yMVq0mjkvo52nhWIdlUmSbResuPBfP98HNhs+waRc0gM3o5iYsDMPVdY/1lM9OmF/G3zBaA8i2XuJ18DlAKWQfh2t/kWUS4ynn2Vdkr971fmgG1qVVtA18pjfAc+seYmVry8fynGGubngdZt4Wdrl9JOMltkeyq0hyFiVZrkOs0XbwXLWC9yMqWOtJdlBx8p5dDXewz04qphRjhBBCCCGEEEIIIYQQQgghhBBCCCHEbYlejBFCCCGEEEIIIYQQQgghhBBCCCGEELclr2ilVIbEVhHSSbQRiqwWYEuSb9mA3Sm3Y9n7UJI5ljQzfpAmB2NpJsr3UMuc9icDHKVadVmfYY48WL1CWSl8F1ZKlETtD7gPJKKxnXYTlHuqlP04lBam9H0B6VIkgZYtkTyk5myu9BPORRsbyKEXI/sISPePr4WuRKwfrWWXE6uWeX4/6ec+4XKnc3d7mZ2fghwiNfZRJxo9l4+ipN0WpC6TgUtVUSo/tiyZbGIZYUicG+Qj+y4HF0oz0bev72Rexyrze/zwqLc91mHcj+5YSq4N6XrWrwKkNYtlWJZhe78P6yvI+m51sA/u3cam3991WCYtb7qE2Dr9NBATBcRKE3K5LUjiUdqviP2hBGjlSDY8W86xApn/yMYLsdjD9o2mX/sUpCan0fZ00a6Uq6MMUfLuzKpLELIK7YeE/wosNNq9a8v/RQpleSqS0S6UrsyRNAvXljq7mVCCjnJ6bHYvLbs04Z7dLnFcyCmjAWUu8b4q21fGeizjl1faeVJyGXvmfk6LItomZO8flQfkvq/osHGc7O/S4oy2QLHtUZ40YXZbHvdztDBknUS5crzBEI1kGdkX8my0xipdtW0AGWvWp17UnkN+tUirOT9Op+ttWa+L+MZ3qzWXVuV1R9ZPlCOkVVuY7Hene5G+Pi2jcD2oDrSqanb8u6uwT4LbolXRrieIS7aM6CqsCYvII+zrMNQuV0cSmSUcZFDBf4IfsFbw7WUMhnuw8BkMWE/8pItz3q7vPnwM+/g4tod8tTs+ZujDfoRWSrOwUZiqsI4jEAijHQAAIABJREFU+5Q2psVS3T+YhZUShw/oFo0unX3eT9zzOm0acZ+73ezt201MHeeH+nS++wdCZYDYauE8zAvLo4TzR3Z7tFjC/uXIpwTnHU52v1jEuK2GeRDb7zrGK3VI85doz0G52sg2MkeOGjeq02NDjfEZ5NG7Q6/nyfhGVZHfQd/HQJcuueT75oZ/r1rOttPr4abSOrPf93zNwQ6Clky0T1qY9Rgdoi/soU9tM0Y7PvfpNjf8WjouxxuqnDtmj1s49Eqi/1h2Okc2eMC+hY0A5+pju8ki5pah4oFZYR9d8LasUHNp/4uXfV549oJb7NKChBaphOOBKciPT894g7C66tYglDxOwmRLY0dE3nbZEvCR3PlObJJy7Y6Yzl5jSPLmR8Ur/r3y8xw7pmj/KJ1hFWRXWDXRMinPtm4nVlHsnzCueN8Tnv74peuzT8qD49WnL3vb8P2/4ef6sQW/mIdehw6IK36VDDsqWinRrqrE7dn2SawrkaVAMee+5XoXZG/Pc1qd9J/3Hdjv9jxbW76+VcH4qQDLjFrNLU0uX3ZLky4GSm3YCUxXve3qD7LtEjZgv9PtwA5lzbfvgpR9qTg+V85ibLPtVgJPP/MZPz8s49tbnsfZeT92o+l96mDg192ELRHXiVptX9PZanh7PIVBXGPL++aXTrtFDu0MyxXYB2LwXVvw8h4Ez0OlDQl4WK0whPYu+prYFOyIVtve/2xueB81A2vDhXnYM5W4BjNaq1rGPWtv+vXN47r37vbzc1y6irJs04aGYQyLr4sbPuZ59im3wPrkb30wTT/yFrcAuv91bl21AJus7gb8gyaQE7ADo7Uxn2/MlT0+No8/mabPP/dEmp7dfzBNH/tmt7ihJWhy2ct9zzriG+edwvrjLKxRNjDW3DO2lXjdXbCQ7Pm9W276Mdodj9H3P/ss9vF1ghrqHcecFy+5zddjb35jmr772JE0zfWogDWMfXvcCqyGsXEHYy+ueXQ6np/Tp0+kaVqQb2DdvgMr0pmyH+ehg1ij2fA2qb3qNmvty27F1u57XN696tZH7zjsxy8VYXE3bidmy17e/YHXlT2J16eF3R7DjYOPpunV559K05zU9s9+Ok1fPOdt6Gbb93nd132nH3/Ox/LnXvpKmj7/ssdrd/lEmi52JzsWy8Xsjpv2KrROD3mLp9nD2Gh4doXJhu8Tn/ma+dmey5bxPK+EGCrDHqQM61ruz/U42iHRDjfw2SstYYo5a6pcG+AabCFnwMV5Na2UUIBcc+R6LNdgY8t2LvZwnufn6iNvbAN6DTxvYd/V9PTW1qg+N9s+fuiXfZ29POf1PaAN78JutIMFmwJskvcchv1UHe0pxuxFzLfXl32u2Ztzm8o+LJn6i5hHrvu4ZRL56P/4aJret8/tpu45drdv3+t2O9FafRRbjKHsmONzH67v1GpYX8UCHoaU0Rrs9nNjrr8kmGuwf897ZhOtX0SxhTWo656tZZcB+84iyqCP/V887mPX6YceSNO8li3Yg7IJbbdhP9XwfYbR+w+enz17fRxQm/a+Jcl5PhM3uaMPQs6kLHpGgnvMZ50d2BpynB6itQi+R5L9zCt6BBA9y8nj2s/AJ3xKKYQQQgghhBBCCCGEEEIIIYQQQgghxKtDL8YIIYQQQgghhBBCCCGEEEIIIYQQQojbkle0UqLgTB8yeCFk2xDQDmJQoKSRy4jZwN/F6dJCxCB3DMnOfmSpQLkdPw4ln4fj7w4pFR25UUDaL3i6Nu2yV0mSLVcWyf1Avmlu2q1qahWX5FqGtB+lvwPknijz3IPOPyWMSgVIPsLapgzppxIk+pKQrTM3jH2scEzIEuEeRrKJdKaiJQTy3B7LX0VSa8gvbayakCWrQCbq3Ckvsw9+4Itpevoxl5nbc8QlvUrB61YXBgc1SKcXIX3YaaCeVVzKqX8LSWNT6ipEdhj0DNhA2iU4reCyp7nH53FwrvKCS6wxRDYg05n0r7ZVoj0Ipfp6W9n2EZG9Cs7f6Xm6BTngCvwuNmE5tAY5sbWGS/JR3rMCiWhaN0QWVairfdT3KqwAqmgPFmq0foE8HCTcGLuU/KpAGy2SRUZ718Nx2pApbEBKbb4+iilK+LchqdaGNOly32OlCln7+qxLA9PWha1LTlMT/Seqo2iMcwXNJtsxIoJykG1YMFSqLr1aRfs2yLFeKkaSlNlSoiSWucyWMsyTpMsi7/MEdaZUgeVBnoReJMVJy7vMLEaSnpRkjN0arn0ujkMKhez3fSOpz+g4GEtEx/H9Q1zrM49TjHbJkielFUi2dGClnJ33PupWCdLVtDoqY5xFuchIipX5suzrLuXIIE4kuJ6pGmWeIVXZ4xjVr21pE30bKhyPM0D7TScHlku7zzz48cvIQ3eI40yPxoiVKvPl/d/stO9bK7Dv9PM3W5CKxZi6Bl+gPcfu9fzCYobWT2urLi3d2MLYuOt5m0GVnMaMoc9xHiKWtoJt1O0FV+uM3TJQTlFXEQ3DETs57hp93NsC+vU+nBOrU6OLqU8xzi2bHAvYtZafp1byDFdoh4RM9jhuwZAHw4pIWpVjpMhub8LdPmmxWoa8dA0y0gvTbK94ndkWdiH250ihrVQTVpddjPUHkOPtobApLTscj+caKy7JvNl2C4PzSz6O7qENvrDk+7S6GBOij6wg3drwvBybYfvt18T2ew5eYy+cvJCmH3lwf5peg9XC2XMu6T415cfZWIHM96IHYBV2DP2mH2fY7yJtABZgHM+jvOPxRo7dMuay2xLeoej5DUXM2+ou9WuwfWjDOm5lE/a5kdWjIZ1tKclxQrXmVgdd1BvOXyk5Xq7Sg2cCYZvGRiRqPHP2zx4uxO1x7vGz94+tia6Rh7zvRZ1Gtk1SlI7s2XK20+aHq2FZFk9XnjdSqff9Xzrv6f/0HMYJA45qbwxcC/jykgfsT3/U6+c/O4rxySwXtOzqdJ59Essmx2YqGhWjnJKc2xAN8qP6lFNOeVYKEz5EPXPxRJpuNF1Sv4Z2rNPzvmVoPmDpJt42r295Gz8z4zekgnZsZcvtUHoDrMsk3keurF70Y677ukgD9nMHxtZHpQQWg4nnkf0cb8Ce3YfT9F2HXAr+7rs93em75cFl9LuzM7vTNK2imltuRbSx6f3xmx59PE0vrZ5L06fPHU/TRc5ZMa4vof2ernjb39/KLo9dsNfbu8fXwYa0ollzi4du29eeFvDdatnPdeqc34fOwMu2Ox7/lDAOOrjHLZPmYYXz5Be+nKY/9tFPpemjj96fpudgkdXGmtsSxjAbq7AkfMHLb7js19T5vFvCfOn5l9P0+WVfs+1u+XX/ix/8VzZp9FDO6w2/5hcvuTVGre736NiCl/tu1JPZNczdTrll0S7Ycp18wbffNed1poz11cMYzz38RrenennVrZQ+8uToOKf3+33/9AnP7/MXPSY24TvRhL3Yg0f9Ov7IY4+k6QsvnUrTNVjvPrDgdTayK0bT3MXa1xasxgbw3m1jbbiBsdrBA25FVYEFK/O8vAYLNVrJY9312Lwf/zzitYH2rrHh9XwW8/O7a1635/teF4bdq+3o+jXYzJXwLKIIu7iFo2m6Nwc7vDWPjwbWoafr2barZbTnX/zkh9L01II/91g0WMp1vc0vYW6z2prsCWOFz6xyFn2joQCHjSijaL00x9qVa2BFnLda9f6tUvX4pj1SMbLjq4y/h3kK1mIj+5Zo3Q3JnDzG8yfMqzAm4xwkskjpZtvFFovZZVxEHR7y+Qae3/Si+TPWhmiNRDtfxH0HzyJokdhqev/QRLw20W/wmSiPXwij+jwz759P7cH5/RDW7/k9wfDBqhhoDqf83tcrPjem00556O1goedxtr7m8be56uOyfa+7y49T9fZ6bcXbmknk5KnTafrceb+eM+d8+8MPPpym9+31/qTfZzuTvQYQbbfs+XgIfhxaCQ5gT7+JPmT79YES4yxah/Q6wDaCa+MhWpPnczvL5touPLnQ5odTFr4f0Wl7fW5e9jEt2xtDX8g2YKvl25stPNtGvLJMFnZ7fxK1VVFjhWcyGWUSP/4Lmem8dxDasJ2swoKuinFW3mSzUGCdy85jyGlzr/UsLD6TEEIIIYQQQgghhBBCCCGEEEIIIYQQtxF6MUYIIYQQQgghhBBCCCGEEEIIIYQQQtyWvKKV0gzshTqU1YKdyAByj5HVEKThAt6/KRddJqfQd0mb7tBldQJkWGnhRDuRkKMDXNqWycmRQhrgeLRVqkE6rRAgk8Zz5shez0+7DFcXctuUCpquu8XSENI/PeShM0AZJ57PMuxvAqXXKCdHiTUDlBbCZlp0UOq6Rxkzlj2Ku2DZ8mnN9uh6oe4Uy9NBMpuyVZQuo5TU+SdcSnF+w7fP/D6XiVq8y8uV9a8Erecp1KfNht+TAizB6qUJl8aOgGRVgd4DsDsbuhRZ0jvr28v7sL/fmwQyudZ6ydOQMC/W/bthyst9bcM17CqUhB3XjWYPtkTQRqxCzraOdBteD90BLSM8W+0uLAx6sGeDJDEl0RPU5QrtKaC9VUaAt3K+S0n+6VlvJ1qot6tbngdaKrD9oG1To412qOTX0oHkarnmdbXdw7VAhnSz5ccpjQO2RKsRlDHtmLbQFhw44LZbB+5yadcrRdOy0znkSNnfqnRhN9Bmfai5pR4l64Y5Ut+UwWP5cjslAGlFF0lk4v7RzjB29rn6Hdg8K6Ioj7S1CNd+j5YyhZQJpYQerUK4f5SHSO2O+URbku0MGJ03ybFDyau3kbQjrYbivXyfqAyxR+ZNz8tL9vl571lmluTsD/lV3rdY0DJbdjDJroqRVdOkk2efAacTW2mi7sHiZgqyxrS1KRdpVYj+AWPXqZqX0a467ETR7zXakLOsj/afmqV0vI91pg/dnab3HrvPv4exVJ8XhfvOdqffcgnnpZeeT9PDiku8hrLnsQU524Wi9yWzFRasJ+m0wGrSRV2d9ylEZFs4RPnVKmzjsu0bIgcLZof2Rfhur8Nxhh+/PraSqMFRko6utHIq4UQbPUiuom5NI+811BUomluhyO/i+HSYyWmbaLe0AwXQm0oVhVqFfdJMlfMztj/04aC9Ee1zfRfaEK5izNloss9B3MOOoQVp2SHmr/3etv2rn6fThj0rLR06fs7LkLpnUz8z7d/du9vnhZtNrxC7EBSLsDeqQ8K/jHI6fc7j+8BeH58tL9Nmw/O5vuoyz2XUpXrB9wldL48OrjFBMNDGNESxThtH3857Fdm95lgMplP1go+jBwUvvwHs54awHbm87DYCFy+4FUcbY/Yi5nMJZL0t6i8xb+h4GVAaugh7JlpDPnrfIZto8myS8hwh8/bnPd2B9RLtbhI2dnnnimybxjvRhofH4PfybI+4PcoXt+fZMOVYLEXllz0OO37Gt//Ah/yDlxtfPZ8fjrF//Wlv477hs14of+w7MKaEtUxqpVTK2GYWD4B5SSy/UtSJpeR1WzlDzvh+5g2U8+rTBFIr+xoKbQUHQ5eFH/a8jTp3yS1rOh2/j10MKrpG217vN5pY/+B8sYT1tlrF68Me9Fdn113u/9J4rPvgoWPptlbLPQn2LrpNJ60PivCTnJn3+fBW2797+txzafr5lz6fpt/86Ls9X3u8fe2ZlxPjcq3t/cDyi1jjSrwsl0+5VczMXh9vz855H7x52a+7inn1Ydi9WOJltgSZ/3bP81ZEpeSaMCvok0+49dF/++VfTdP3PexrLbX6aBy1a9H7+lPDk2m62/Z7/LlPfi5N9y57v999yfdfRwg1YC9uWCsoI+Yq6Bcf3LWYpg/AlurSupfBHGw2+sXJDsYuBvib6PMrNY+DStXrwIWGl2kBNlidtl//A4WvSdMlzDu2Trvd1JfrXlcrR3wd9a0lt6S4b4/b79RgD/+bT71oZmYfOo6xDuaWbDv6eJ7AcenuRa/7HMvVVjxfX7vX62wBx2nCcqrEtRWMo2uwYH/gqF/fEsbJS7DcYrvex3rmEHWS7dcA49LzF8+k6SefeTpNT6HtWV31sTHnIvt3+xxlbc0tQxp9z1tALGwvx1ZqWNOF1QPHh7bP78N+xO67v/WPpOmP/Lef82O33aZkC+18Mu1t3yOve1uanpr1+7N2ydu7jec+nKZnMG8v7GRt9iZSn/FnCLRsj+zY0RbRAqmGuWYJ97cES44a7FErVe6PMX2Jc5mcPMAqaXuBYIj6GA1FkMdi9HyOA908q2QuRHA+zM3Yzmd1eA43oG0w1ks7HT4bwXNKWB3REq3Z9DSfC3J+HtkS58yteO1cU12BvVC7Q9tHy2T7Ng+xztNcw/MSPMJCk2i9Dtb8pvyDzXVY0G3Agid4HSoPPeaK015fe1Vv11p9tzqu4lxcI2xO+DpqtF6Ke33hgts9bm54fTiw3y0AN2FvmeQ9L0A6ybFgr6DtOoMxWbHk5X7unLf9m+Nx2G6MUaxAyzS8j5Bn60S7NaQH0TMYrFlc+xGFxQ/dEffRMwHajvvWNzz21jS9SLv3MtZI+tn2hA3ch07Lx3l8djA752Py6dlF7MNnNZYD79sonXAyGE3osp8XMrYHWGdpIf7LuNZSZI+NtianvygU0I+insVWSnZNJjtahRBCCCGEEEIIIYQQQgghhBBCCCGEeJXoxRghhBBCCCGEEEIIIYQQQgghhBBCCHFb8opWSlNT0BuHJFABUkuU76f1DlSMbDCk5BdsQGCtUy/7uXjeAHlb2vb0IefVgX1RKpMNyU3aGlCCp9+DDBCS5Rqk6QuR1m+arJYoiQpbEsiSUb6pXnF5oGYPss1GWypPU76JeQjQcqJcNaWfIqMTWmvQwoJShrAGaUFim1ZTlOQu4ph9+NsknVGaZdyFRUHiirJWqPg9Zn771HGC/cD6i56vC0WX2dr9zS6JeuDYgTR9bv1cmqatUmkAuSzIHE9B1m/SCYi5BNY7NoT9T9/lLyNbpY6XS/ReXBdytU2XobT5I36cubvSdG3/Ud+9/dk0PYCV0rakXwPSr1N1l8Ya9lkHIZMFi6tuB1ZjPUpreha3aBtCawVYSxURZ+st2mn5/ouQsg84ZhfShH3IhxbM2wBawtD+ae8MZI55LYibFiSSpyBz3IS8Zr3sFzZd8zKkFdQUt4/lCwf4fHba26AtWHF0sc/+e1w6+eC9j9i1oWxcnjcL7WlgpTDhUp95lGAlsDDj8rdJjjh4ZHcDqeFI6hpyk+zbciUAo+2QRIaFAOvk9jfz5EIJ5WyLhVccIlxFZGOUYzkUSfJRpjBHpj4uy8zNFpdN9nVFh885UIisHij/SInI7Hub5OQ5PXHI/DTKV5xzlBMlBS07LzxOZLWFI0aStTllll9Ok0cN8v11WAP0YX2z2oLdDcpuYfZqyWQzsxLs6WiF1+5iPDflcTFTwZgWpU2rJgyZrd8fHb8GC5EC7DLXzro0a6j4uGT/3W6rVJuBbRskvrcuu3T8+tkTaXpj1ccDPdqcQjYWXY8tVGEnleNswDF+E2Os+UX/wjSOg+Fk1L+GSGXYv9tH50yXi0haGLK6cEi0Cr5bm4NM/LjIWfc5DoGbqbUgiwvnHptGgdRxfVADtVUMp9rIV6mEsilktx3YPZL1znDDmyiqNa+rtGsoJJz/se3CnAJ1iV0b5aUpBd2AbWQBccQ54iZkZptNn3MVsU86Hin0MvdtNX3svIVxWsCc7NB+SNDjJu2a9fJ4x5sf9Hy1IHuNeWcPlgTzix7T3/L2h30ftC97d7slWgG1Zm3dJY9nMSbsNGBRhSCKRhLs2/q0VXLolsDpWiHq4OixAjgHHac7GBf3upg/I85aPQ/AE6dcTvnkGZfDX1nzNi5//IXxEfLe7bI+of3HeOrAbp9rfss3vMUmmjzbo5x9IlezHVkv0W+R1kTXZ58UNezjfZJceyMeL9tyL9diKdc+ybL3ybN7wuYnX/Sdvv+3/LtfWfdo2TWTXYDrbfQbvRs/xmrAavinP+zHf+vjfjHH5tDTbG9m+eXdvzy7Kt4rErlRYuzB+reDMXAEq1k/Z58JgVZ1tWkvvA7sDGjXvAJLnGLJ2/g2BhJVjAvr027Hsrbm7STbtF7HC7tS9nasXvd99g98+7mNkbXI0ye+km77ujd8Q5qenfE+78ylL/j5XzyepqenfcFvZsrX5tpYY2y0vY9+7pSf6ytIl2CbsW/e00OU2RT06CuQYn/u836crSbK+/DeND1XQz6R3lrz+/Zf/79fT9O0DnjD1/gayeplt2O5eM4tajoNv8Y20lOw+Ksd93H7y5uj8z4Da8BqThWfwsDp8B63b2lDpn4DNouB69+0HkW6gXXo1aVl7M81rux1nElf07mwBgtMrOtN1b1e1es+J+JYYH0Lcv99j6cvfuCDafrAlNsT1Ka8Lq0NfUxmBY/XVawDBqwtTmPt8qGxvfnLKz7uoaV0ZFVOa2qM8U5iTnkaa5IHzOvYnrrXpWXEaBdjywTPaUoYCNKKa/WEn+vo0cN+HIzZOX6uTfkaWhvlMUSnw3lQB89YNi/7evYm2oPGOc/DFG3rN/3+f+i052dlned1tou2WPK2owrr5K//ujen6fU1v449iLMKLH3m9/p6+uCkWylNTfl8ft+b35Gm737oTZ4X5Ktzlx/nKxteL9oX3aZuML3PJplDWM9g81aGHVKeHVFsk5JtTZS3lhdZe3ANjHMinpfPAIej/Tm9KcQesp6kPU3H46yDdp+W5x0sIHQ62dZIreZWZppWR5wDc05J+6fIAjda+8OzMpQx70kZc8oS5keM0by10zaufZDzXDZvPXR7WXyrgbndJixghljnwfPW+jTW52a8bIYF3Ic+nv/hQWWBA985j+/p+936cLPhNuXrW25314Ilc7uFBaGJJHvtnfdlkzZbsOrhWlq0Ns32m40XipTxPY3n7ssr3k7Pznl/eXnZxyNnzo7avcVFvy/Rc3OMjWIrM9gn4R2EQvzSgl9TZOGTNyHOaYNynIau/N82e3f5tTxwxMdztIbm8/d20+/DhYs+5tza8v6KzwJ27XULrDL68iFXHROO7UB0E8dXmTtxSzKTkcESH/VjrlJBOzhdx7sPbJMtuz3nhDTJaYvzyp5M+FKrEEIIIYQQQgghhBBCCCGEEEIIIYQQrw69GCOEEEIIIYQQQgghhBBCCCGEEEIIIW5LXtEnoVSGlBakAymRRJmeWtHlqAaQBUxg09IbukxOEiDRBy3fLUiMztRdWqhapvQ8bJUgobdtHzEsZksNxhZCw6u+Z2ZWrbi8UmQ3YJQH8+O0IP/c6dMOycumRzlxpClFSwn/WE+d0j8sM2yNLneI7dgfMleUMetThq1PzX9IH0JqMxlAOgvSUoVkVF8C7QRasF0qejlRj7uaoxFPScMhJJtWTnh9ev63XYK0/0Yv+/PmkmbzB1321QawwIKlTtlcqmryQSyWUGe60PuHFGYCaT1WlBBJANKrALHbd9nYBPWWUnllWDh1If/aGkukd1G/pmp+njJkzVfX/J6WGH/Ypwf7H0rsd2GxND0NyxG0QQ3c606P1kj+3V7f27sKYo5WTTOIUcqWtnFM2kTsmfVrOQu5sFaXlkwO88N9AprqKgK/TDnTEuNytE8x59XHBspsN9rwR976tjQ9NX8o+8vXTbbFUsiV4J1sOd5Ymt/LfIAypQzlIFCa7notf7Jtc+IyyjvOK0uM59nksM8Y7uBW5NkzhTwZdBByJPFi5UVYbhQpj5ptl5B32QVIfVISkfvHkp60Orm2BVX+/cncOXszrVPQxrIvjCwR0QaxuAuRBQvb+WwZ2djuDHY29K2ZQOZgz8h8d9t+zVMlv4ZZ2C0NjXFM60o/zmYP7T3KcRba5jNIc2w0TLwN6KF/aCyNrAorsOGpVH1sO+h4X7j0oksjD7suZbr7kEsp1+o+7u423E6kC8n3Omz0hpCrbqxcTtPTVa9LlTLanYR9NuTXUd5VSF4uzPjxu93s9r4YWXF4EsPMyKqp381u7+iogaGmlaZ8n6k673lh/C8kOhFDbMM3XM3V4IAQ3bci2vYOh/Vljm99Oy1J0V1HthKoKjZAG7Q5nOzfMdQxbisl2VK0A7ZksFViW2cYj7B9W29gTAsbS8rkdht+E9ZhKdSFnUAd8vGl8f2jlRP7hsaWj6lXm/69GUjvF9EeNzvYf9Pr0kP33uv7V11a/TQk7iu4v7sW3Ophacklcl94+Wya3rZkMzO758jBNL0Cu4DVNbdFXcDYu5LT3rHbivoQBiNtlSFFXEYbVix5+WCaHdkmbYzlfpc3YV31/7P3XsGWZed93w4nh5tD5zjdPaEnYQYkAHIAIpEEo2mZNE2rSmX7iUXLpQf7hQ+yXE4v8ptdZllVNi1ZlknTkigSFEAKBEhgiDDADCb1TM/0dE63+8aT8/bDvXf/fwuz10yDAoWDqe//0uvu3meHtdf61rfWPuf/G+vYxZLs5SeR8voBOsg28EkNdFjaieexbsAyx/oIDWAC5tvKnK7hMx95Ki2fP/tQMNVykEbZsTaL9viufRhgffgkYpjYlHznJX4HKMR0f9/5fdgeLz7Jd07PdhzTIYGhLrkO8bUbKp85pov+u2eBK1rNzktfuak//vHzihPfuQPr+x/QNOjte+ovf/wNXedviu4WRPvPwVdPXqQWyrFnH5/bNtsN1x88NtzO/lyDCn9AFfU3pKs3X0rLs7OqpGZb4xORyOMxKj7SsxtiXbSQ17poGCo25iPZrze3hPaJCsA4j5TzFQLFw5UFjTmDvbWHtZaO8e2L30rL9xtCIwUJjldQQh5PNDa89tLzabnd07UkkQaHOzeFkLry+pW0fGRF9u/nHj+XljtoM9so72wr733h+W+n5cOYLNw9IMzIxo7y7T7wiyGeSXtH9XASKJq7X9XxNzrKTypgs9awDjzBel1uVuiqLYyLvT1kZI8IDTRxpIdBAfibNdzHFpAxRIE7i8ZLl64DAAAgAElEQVQTzxjBebivXzr4hCRj63Tq5h2hd7jOf+Sw2oODc0XdITUJNrG+GmKueRf4sCN19a2ZSGvQk1i5UbGmudsFoLi+eVPIiIcP7bb/Ec45U8DcESjf3ojrr9p+/bbyxneKupHXsf/dmq63vq1rCTB3TMq6V+f9ybraW+G68JbdK2tpebai44yWFD+4DhE7+Vl2Xtpqq3+/+MJX0vJWU33oLPLn0Uhxky108dAZba0qb79y46qufx97ijZRxby+uHBc115R7GXdbzb03FbPPJuWX9vRdS2vqD6qK0IMbezoszFixxh1UznzSe2fO5aWz5zVnGMaVSxi7pDTcy8AnUc5GHAH25ONMfEhjkZ8x+VZNxxjDjAYErmz+1x7XW3juEzcL7FBXeC/iEwiJok4JK7BUr77I9IoB6xgpcy5j7b7EPbO8DDmexLEGKAh+wOsNwH/xP1HfN8yYhnvojzrpS5WaZ+1qnZTLmssXljReLp6SHF4EmPdINH+1YLyioMHhKzsbulaeg0glrFgE83qGkZNYAgbev7M74ZoC1Op7FD7rr/2xfbJ9sN1HN/aPhP5YlFtsoZ+3+zg/dSyxuYO6vHqtatBEATByROKebOzeo78boLTxnElRPrFWAMI8Z6da1AP8s4mdOYjWAdzmPF8ea82drSicWh1VmMY1ye66GcbyEuvXNcYP8Tzqc9prrC8ond6Cb/P4LxHQDz14YjCrH2z24qbQvKPbJQaY2Ue911C+3DQeBHfjhCllP3+hvg6n6Z7pdVkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZPpryr4YYzKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWT6QOo9UUrVSgV/yQJrQBszlHMx7Y5hYwSrmw7QLF2gX0JY6dAGebsnq6B8RPtqXXoEO59Cftfiagz7rIljo4M7Ao5lAgv1ImzJiByKQtotwwJtRAsxlWnT1IN92yAB2gY2vbS0HgD9MsrTuhp4BdqV47xjWJTR8or3QnuoCdEZsDrL0boONt8+6En4roLr6Dx2EDaqj1IR7Qyf7Y7UPkaJnslkonZw/W1Zub1zQTaZ+UXd05lPyTJxZmE+LcPFOei28EymXElI2ysiD2ARCDuqBHbwIT3jYQdP+3ryd8KAtoOweUafKwdqqx207dYeVikHi2ra52021B46A91HDNRDoaByDDt32ioS/7UN67sJMCDzsJwFbSm4vgEr0S3VExE2efiJ5VCmzVinRzQS0ROwCUX/3umivfFceAxzZdn1tWG1W4MFJR3F20Av7dv7h0n2dx8ZM0+dkr3a+ec+l5bDqBC8r96f6PMeH/i32eeHp05P7aRWrWfu4+DsJtmWkcSBUW6c5jFp+wnbPw9SKEteDA/3gc0m7Td9OCHfOd3N9OTjZyeZu7AtjSfZlnih43effS7GAKINee+0FeWzcsYujPe0XOSFOuNxhv0izzOZZI+irI+IGAGH95SNU3Tuw4PDcvFlP/qaqeqZrm+jb41UnoH9c85BSSGux8hRh8CjIX7O1PTcy0B1chyIC9o/yiF+5oEQae5arJ4oy8p1fl5xZNLT57buyYp60NGY3mnIvj6YwKYbbYPYGrb9ElBAjbHy5DKQUHkPLmGC9j7GeLY4z7rU9mGXYyf6CvEUsKhF9QWe8Bgk4C2NhyoXiU8CYovdNdmz/45KsiklUquxJQTnCOeZxfGIk+oPUB+43nIe7YxhCu3SMZp1LEt1zAbShOh9YvsPXZjPTRyGI7FKRLtiHMBzzKOdNDEPanbQlgrIBVEvQ9jMDnv67AAWvHGovrifzw0x73nnpu7j5gbwpGjvMqcNgkjuzMFDDwlpxDx9p7WFT6gxFYDKKKHOBrCrLteAZjkn2+CwK/v6jTW123ZPdXypKTvnIo5/6rDavzsSZaBtArdN0tY3AOIoACIgzKtSwlB23o0tzdFefvPG7ra+zlmta34W5fQsS+jQHcTBHVgJD2BpThvlQhHogrLQSAk6LOcWpZy2P/ehh9Pyjz39WFouF7Pt3qdFTn7mw934yg7KKBuHRCdjx4b7+0XuZOGZfNfiOzbLTNroXB2zPrIxUL7PJlzvQtP/9U+g3QLRWAS6L+EUCuc6AxLXmRX9x9/5XZ14rf2DwViOkAB+/gW17V/7BZ13eW53O5ZZXEtwkqZZH8ynnLSY3uKe+qZ4q2wTjE6+dubsP32aAN13fx1rJRjb2F/jCKiOAtZZysoRByPFft59tTyH7XhoWLspA3s5Xz2RlrtAeM7Wd+Mt12XvAru5ua1ynuNiSXG/lBcaqQ2838YtbR9jHYTzlw5QLvmO6unCLeXDt4FMCjE/Y3NbwbUp2w6CLdjOT4C4LqA9D3DvBSzM3MU6y7AHdA3WtnpAOnaHXJNC/odnTtz4IF3Pyra0d9BkGN8nnrmNgzT2xU2IOIQc5xAeDPaDdO9pUQF5I7EnCeZNNbThHnCfLTzf0orwDh/7tNbMDh3RWlpzU2vT41ADwatvvJqWJ6jfC+t6lkdmlF/k+3v5zkTXGyHYVtCfV8rKn67eU87JdyrNrvr5U4eUB755V336IaB6SsACTSJgY5BT15APxUAeVBGoa0CRriE339xQn+5g3Zo5OXP8Mu7x9JnH0/Kdazd0fMwDEmBtSyW9a1io6znXgTcdN/XcNiZbe9eSbgpyxGsNdL1zRdXrbTzLP/zq1bS8NKvzFGeeTMuvbag+br4qdGoy0X3MA73GHHxjR/t0xsI5HU34/m76VK7gfpy5RjZig/s4uLMB330pjhKZ1MOcgSigMeKugwhCbBgMVZ7szRmIPeL7s0zcSBAEEcZ0zjVivDOtsg9h/sL75hjp4EEQvxxcEa6z01H7HKLOeC/8LNdInfVEd1FaRY4JPlSTs+6qwxC7QzQmh6hiYbd+6jNa7yrXtMfSYc3VK0vIDQLlRHMFvQusFBT7+gPFPr7nzSH/ygFLtdHUPHZhVXPydhfvtHYup+XBlKOUfDjExJN3BA6ayIPicqaOaMM4TB5rf22sZxAnOj+/mJZnMFHYaezmiLfvavyYIUopl92HAs97DGefKHvimRAFzkPiZhNi0BK8F8T7NM6tNjaE0/7Wn3w+Lf/Kr/9HaXnl+HmcV/fVamNdK+Z3InT8c+ce0XEOKD+5d09rRsQW8lk5S7Dhu/9wKUlOhWDP7LmgD9M5QC7f6qpP5xA3c1hb9z1bPkO+ZsqFnoVlaNrzWJPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaT6a8l+2KMyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk+kDqfdEKRGTlAdeiPZfE1gFDeE3l8DGJpeDLWBep8zjezljWGzHE1kFjWABSvRRJZa1cqWkcn4PpTTM63iDENcFyzHikzpt2YwRiUDL4GSSbZk2GBJXBOs3IKSGuA+WHVunDuyM+rSNw3lhvT2mhTiuYQSrz8mYdmvZqIcEFpERrj8O9ZxDVESRttOOpfnuPl3YGNLOjm0lAZor4P2hTTQ7stYaDoiSkR12DrZnHdi1Dt6GBRNs6R79lOyww4o+OwbaaTpFj7IuNsNrH0ivYEBUD+2lMqyrg+B7bLURFnL87pyeWRGW57S+6uE5NfcsOGdKtDRTu2t2UeeIF8OxrrHTlI1htazPjuCG1YbVJy3E8mBlVcFoWJmVxeQO7D23WjrXcl1tv4M+MYK5GBFOtKKrFHWuKnBIC1XtfwMW/UXYyeWAvJiv67O1kp5JA9bC3R7bLa6hsHscFwWn/1+s6f7mwYkoVmVF54r2Yx5rXsYyx1KSn80uhw5qx3MJUyJiSRx3QY+ld95B7wAH4WCKgNNCfPUif4gBiGmvmb1/liKPXWCYZFsjUqHH1pRl90FmX0uS+HBIPFl22wg9tqKsA9cd8f3ryXFo99iZhg4SScfhOMP7Sj/JMEyrfqee+B+IO4jtMXIx3zOOcQLffQfeZzXd1vRUs4s+gbxnoYT8JqCtK9ub7rkHlN8Yz262TFRokll28mRYrudLGiOD27KtnN0bf0pVxffqvOLupMecTfG9WNPxKjPaf9BT7kpMRFzEvcIqcwxb7TLwUDHt6Ik9Qnvo4jjzM7CaB36k30Y90aIVzWrodDQVQ2fYYH1rexf1M8ZB67DVLQFtMSKmYa88aW7oepF3d+F4W63owmKgtorAJBGlxDCPFMBFQhFL5dDR9EcP+3dHsCLPT/fA2NqRBXmpJNvhakXlCH2FFs6NDuZ5zm0CGRgxX8c8jvknLIuJxaOXauL0+93zDpBQXrur+9jqAuuJvk0b9mOHBVZaRwNKeL1NWTvv7KjtBSPl8gO0w0uomxNnZSV8967u9cmHjqTlSl454de/+1ZabrR1/CVc84mDS2mZaUvijP2IGZhHRgWMPzk8W8zzA8wdu33V7dXbsvd/6eK13V3xuQMiFDgYO45h9+8rlvZQTxzzqlXltMRuhbFiLlFKJdiYP31WOKyPPqX5YrWifSbJdM8XvfikB8EqeVFKHjwc9uF5wwc5fhaHw3uN2VgnZ59syqUfn+QpJ57xKQAaab7C+TPqwHc9eeaQ2nz6nMoPAau0duUHg1Ki3ril+PHF53Uzv3Fi99/Ic72+5+fYZ3Mfp+49SBhP2vs9/tyZ5/XNCaZRxIYzXa8A74xlkwBEOGetjbbsKwtH03IOD60AHObRI6fSMjHbOw2Nb7WS1tJCzMd39rCkJx86rf+/+nZa3trUWlsPefd2T9uTiXBITl431Bh5HBXSI5KirvjdA96hASz4CGsfQ8TyPhK+AY55FdihIbYTmcmcxMVisNEnmft4scDfp4SVYNtHfHEwZRgjnbJ2KRIFgDnqBOv4PXSuOmJlBQjIcMR12h+d/kcdPynsxc3rQu80WsqTDiwLR3PzrpAZISYhN27fTMtf+vKfpeWDywJ23bsvJM71m9fS8nCi9nwO6M3rW+ovTy8IF1KId9vkypzWLbca6meLwEM+c+J4Wr6zoX1K88rTyiU99zN41p/H/k/Oa6456qjPdZFft5DTtoChmQWGZozjhMAkEQUUxnzPALQacaxoz2MMqoWScDzLVd1jG3PclQUdf31DMWBzTXGwgEZ8eF7P58DMbhxCiAuurOnYf/bFL+i6+j+elj/+c8+k5ZMHlTceW9Vzncca7OUbd9JyCSiqoP1iWuz1lRzXF4X4XKoCd3f3qq7zlupjGrWzJaRer692NcQASBQQtxN11OecC+txfPc0cuI61wejzDKxHSHmFftrs0UgufbfOQaBi29xl8Y9WCKUOfa02+qLIw/qiOUxsWNEzzuYdl6P84fKznppnL0/5K55hxklP0LeGUNCvgvgerJ2mey9I263NSZVFaqDygLWxPGuaNJWvwmHelbNrubhO0PF51JeMas2q7l3hHw/N1YfXZgFpHFdbbrf0zwcIX8qFQbZz9HFYBO3lI3K+p5Wn7kP85cc5hg7GNNmZ4W5qmEuX61rrGt3dsfLK1evpNuOH9P4znbnroHjaj3vByhij4iNYr41Qfvt9jSO94AtrC+qnbAflOtqxHMHNRksIDfnxIGzwgHGuQ7G6QJQQ+fPP5WWR3hu29sa/6JRD/vguw3OJB7KiAfRA+C13Bc4jBfZ7xz6vD/kGPUq380AIeVcbvb68egB/GDMMcZkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJ9IGUfTHGZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyfSB1HuilEbwxc0V5EUzhu10jtbLsDGLYS9GFNA4JFIIvuWOBy/t62GbF8q+qpyTLXQRNsjF/K593GQCezV4+dBemxiEFjA8tDErV2TjNIFdZ472YB68wyiQ3dvEYw8Wd+Hx0wEGZgJ0FWy4YvwxSmgbR3wRLC/hS57AMjTgs6KtE2wNl2CBfmpZloXnT8le7AitAZd2LcXf2tAz/n/++OW0vN2RzdhoqLppd2DpBHuqHqyhOrC67ISypyrCRjaBhf8IfvQXvyKbNFqqn33u0bRcqOr+plKJ6iIcygI0GAKjAFs+WpdFwJcFBWKSUHeOBTatV2FzCROvUl0oB+IMtoE16uzhnGZLigU7bfz/iFZruoBaORv90enD8hautbNVXeNGQ/XUAKppdU7XMFuTDeJsWf1vbQfWhMC5DdFvul3tU8kjPjrINVp4qW5mYPVZAIqDNv7zFd3LXFVx7Tasi+/tqC+UgGHKw9awN9h9VjHt4VBcpO0oLIYHLdm/FudkxUyLPNdG14NP8uxDy8TE48E77SAX2u7TzpLoHYTXIEYbcJAEjjsz7ZGzbeh8dnOhZ39qfwx096U1IvAtsP4mtsdpA/gsx1GfaMvJ/R/EhpFinCBOqtVRGy4VYW3qsQP11YODUURQJJIsDrOfA6vBtWsN9zfyRrTvJMna7MZwclo8n2UTYi4WeK7XZwlOhb7PTol6GPNngA4qIBZGEdu5+murp/37Y7XzOsaEPKzpc8hdmaew3Q7H2l6eUW4UF2XburywO/4srcqytYxYP46Uu+ZzstoOInAciMKEtybteEP03WJB8T7pAuMHBGehT/6PigP0g/l51DcsnOFs7NDynGqKs/u608bQpyOiQpEDj3HQiqo4qFSBf2JfRHk82D1mD3lKu4kxWtMKx/+fjsE89gTXWKA1KPs0PkxLT8bzFo7ZBFYJTTGoTrczdrABK9wybK97QyJoPNhZ5KJEDOZQYY4tND7bhUV7s6VxoNWQ1Xt+pOtJ0A7DPbv2LlFqSJT4vHpDtHfkbDfXdM4O7LtpWX/jhuY4m9vq30R2VjHHfue2jtnGuSYYBy5fBQqhqTog4pN9q9lT3Xd7mi9Wyno+YYz5Me2fiWnIq5PkKsJI5QrKqyewt11fU0556bowSHc3duskgl1vD9dVRfxst9S2+sDE5hHXSkXVx+K8Pluq6rpamEeOgOA6uKT7+NiHzqfl2Zrm/7Fju/4ACMgfprKHp+9BB/nwQlyg8OB2PcdxrNW5uvQgOKdc1jYPqseHK3oQhNSDoJqY9jp4Id9nUU/5BzgOdqmCuPj4Mf3H81eCH7gYw/63P1Jf//Czuzdz7sMYiHDtCdNPX9P34RG5j0PsDLO3OwtqnnOxXqcc5VKrqvJ6PawJIscKMS8uA5u8sKD4U8C8ZoLcZLuhdbVNoPPiovaZrQEJgAr7uWfPpuU5jAOvvH05CIIguLqheN1YVoycAZqlvaPxbGcLqKM+MeoYw7CueJ/rO1hb6XQV44fAGQ4cTDzGbCRlRFUkznai5LPngk5e75s2edBg7hweH8BEn3NHZ9rMTrWHIexFXHvLXh8f43NFjGdFNK4y5vNjWOz38nreXBseoi3GTrAkmjIbvZtM+erNJz/9U2n5KhAMb7x2MS3fWFN/KlWU67RaQAoB3/Ld734nLb9CLLMzrVGdEvO4tSUsyADYhShRX9ufUE36+v9HT2pe+OSycp2TdT3T84eFy9xCDnkA/JF8oPvgfGSIcYKYKTb4PNC+A6yJ7aAd9tcVP4rAq06c0A80Z165WgmIqAKOnwAL176r53YUeNw1xIkKHkQ70jE37uv5dweaKxCdMdibeBLVdmdzhM+p/Nh5xVIuuceD19NyeVsIrnCgmLw4ekPH3BByYzy8qv2VAgf5UO9V6iW9D8j11UbbFWHAguDng2nTKy9+Oy0PMMEfo/04a4t4BhxPqFpd/aaCflauABnIuQxyPq5REgvCd4b7WKMhEB9drKdwPZj7EHVEfBLjgoMZylo/DFzcC+vJibo+RImTbxEPE2Tun3jWMBJP7CeKMfSei+Oub80RZeyy/46zhEWRmRXtEJeBpRopprQ2FDfzJfXzXiLkTSO5lZYHoWJyry3E2WLtZFqu1tCeMP8ZTZDfTTAWcO1uKuV5v+OkND4fjey1vMiZLzNn0vHrZdXLxpbqemVVmGi3j6p8/NguNvDCG4qvd+7qGPOzGhfddWy00yi7/zNG+HCZzMF5+HJNMaiDHDiOeXwdZ2lJ4+ipjz2ZludmgIMGsprrFuvAIbWxDnb6jJBMR4+fSMvb22rzJSxubbfUL8ZY04lRPxN+12Pv3p1XGtlhwYvdZGty8kanvrWZ90fUXbWsegoxKY/cE6R6kJUbc4wxmUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMn0gZV+MMZlMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDJ9IPWeKKVCnvZPQAeNYUsNmzFa5UU5Wd91WrKm6jZka0VM0gQWzkPYbU8S2EPGwDPlsE+kfeK98ya0zYSNjs+6bNKR5VF3S9dYLslKcQbIlgTWhH0QocawfRrBHYi2UlFP5UETHvS0Fk9k+JPDgRxrI1hCwanNi0yi1REdjyu4tpMVlc+dkF1YdVF2RQ1gkL51GVZjO7v23888eTzd9tEPHU3LX/wL2T7FQOqMOsAB0Y4JWIAxrO+HsAYdErs1QnOGV2Onqf1ff/5SWm51ZR916vFHgmlW0nkxLYdt2TEGsKwPxtmWdbSIDh2UEqy9aE3ouO8xROiYRdhtEQPRvy+rrn0bMXSnoF4CpgKNsAv8Vw/2Y3C4D/pAL9FSMCyiP8GmcLsjK8MDs0CTsV+iD9EWs9mldSAtAvXZ9aaOT6O2Di6a51qaUT0tANFxswEcj+MopuP0cG2sB9rSMfYU9yzIC/jqI6gZQQHYkQ5QSq27b6bl+mHZugWh+r8rDz7Js09Czsa0e2B7lIeNG60zia0aIEblQrU92uBxPJtgHI0D2texX+q8kYMl8Vlwvts0zotSot0zrG19loJee0+MN00gCetA1UVhtjWiz6LTpfzojx5sY2lTyKoJH6B9sk/TTpGKove3keR9TRxM1e5nfU7b3E7Rmtu1GsRxPJaljvWp0z54XRTtMLOvcxpVzak/FXIc/4mzAwJlgPwM2KMFhjcnjgLtw+fL+kKd5hBX87Tvhd1jfXY3pyyW1CeKGJfDGCiUSHagnZYG0k5PSSdRfyMwD3JF5a6Vedl15tq4drST4lB4xNF9nas+q3qaqyFvQ47FfBtd0amzERATOdTfYAA7XLq1I6ftw80bJJegIudt5znwsxNVZ7BPHG12snFFREoSOdDpE4+R3c8jp1+qXMplW4PSqrg15NihD6+WVK+DKR8uKzW1VeYxgzHHDcRpoijhPZ5zsHEqEoVAi+1hTw+4BZxTByilxRLmUDHmsnttuA1Mp5NbIl8pIl++saZj3xIpKBggj62VMV/Eg58BYmkZ+yzWNX8eoB/cvqV72gZuIkzuoYwGz7kdUUAF5OloY1XM1R2+ByzrE+QwCTDG+bLiSggE1hDztc0tXf/ahuaAne7e3MVjnTvCtXS7mucUgE+qIgBEQCatrsqOvgAcwmS8lpZpRX7mmPZfmlM7ZlsMUXZRelMoHz7JwQuF2fs8EIbJc5zvF2uUtT30XJfvWrzn5HGy58POZ31lYnuyl8Rc5BM/S/ydBwUVlnRtj53FGPlVjJ2TH3zwf+eu+tfvfWH3gn77CZwfKJ7Qg4Fy6sbXJTwW21yv+B5fbRU5/fFNHd+f5PpD1Q7QeYxjE9x/Gbgl5jTdvmJ8A3lbGflkNSc0yhBrs2NM+PsDVfCxQ6fT8umjWp+rI3dt7uFTGmBkXm1gTRV9vjqv+FqbUQ6Zx3jQ7mgNmOO4m3BhLQMDIPEOm/eVCA6A1HPQmSoGFazZVoDo3r6v8buFBarmDnA5HeAggfgbDojC4Fq1b37JelMdj5gzY+5S2kOgJggkzG27wCElxD7ieCMcr4V1/DLzUoxnvYRzCNwf6p60OBfdgaKP5TwlOrS6kpbLQHotL2v7S99+KS3fvaP+NwTuhflcvsDnkT2/zhXUDmdmtXa6s61+EaIR329oTe5QdXf/5QPCJ50DPuk41uyHQ/WPj61ofvndse417BBPj3X1SXYetrWja4witZlDh7XOf/BhrZ//5U2hfco4ZgX1fRBr/m9efCUtE4t66KDulyicMydPpOXzpxS/kjtCB50CevOrX/9mWh4FipsgrATb24zLynvXNnbvfTzKXh931qNauu/F3j9Jy786+1paLn7nalqOsL7T/7DiS+4W3ost6by5u4odw4ULaXk8CxzyFbXF/jN61xEE/zCYNnWHauODHlFDTACI6vHFV6xhINcvYz7QbethE3E0xBhCDPUY87gR3inszzsTDw7ehySnfGuJvvVP/1po9hqfA43BB5x1UQfz5nlv5BwozNzscrN9a9Kqv1zMubXneXryyP13n3PL2lZfwHmQPwwxn+/iHWs/0vupViR80rikeWkv0jvNYaj5bW2oEw+7WLvZ0hixvbGelvMx3jnlmChPo3zt1tNWneaZjeVy6Thcm9b2XF79/vpNxe9zjwpnPAYaegfooEcf2cUFXb12Nd12+bLweI8+/LDOSayTs2ZP9M7745M4uSMunXsUSlpPqdQ0BvP7Bg4KCN9luPnOtbQ8tyQUIt8PdbEO3Gry3bnu5YmnntXxMaFoNZX3Ou9hZtW2GdsmzvukjPcIzvuhIFMuMdf3Pon7ZMc+xqlWR3l6Hn2rhDXvJPQFvOzrpKZ8dcdkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZPrryb4YYzKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWT6QOo9UUrECgyJjMhrexLTdkffsynCPnytKXupJmwrC3lZ65VrsoAb5mWxNgpkdZbEsHEPZI8V0fZoD08xgX0XLcuJekgcmzHYJMO2PWjLBrVc0jEbwJnEsC8MwS4pwOInAvFmtAXbPlh+uS5m70YxBEEQ5GCXRHszejmNaRsF/0tSIqoD3dcy/OujvGygvvKGbKfvb17VZeI6S7CR3LeUe+Hb2vfA4UUdmzZKwB7FsM6jzSqtBiPeH59nQDsreObT26eu6EEAACAASURBVIrVhHNdviDLtOZd8LD++2D6tPW2yrSi9Tg8JvQdpncZLOsDWN0mY1q0s02iH6FcnpHN1+rxw2n58s372n/v2QxHtJuFfSSeBa1wWW52acMXYx+gzMAYYJwawoINtKWgANvrCvorrW1pXd0b0tYXlrOw5KoBEbUDe9Ix7FerRdX9TAk2tusIOEQjOTgQHX9MfAMsjR26zl5ryMEeru/ch9RGjLvymmxkDzz+We0PpJz7fUqfvzXbEGMZ25MPczPd3ti8bideoa5ptc+2yn2c7R5kEfFMHNNoyxfSJp4YpoyxjsghrwVo6JplZh3bZxnKdlqD/W0P400OxycWwbE79Nhy0rqaca1S1LhFvGMUs60SF8Rz8Q6y7f0o37W5zn3vRhOFjvUp9nX6s+d6k+zr5TN2rpEW2B6LyMCDYZpMMBZE75ki/vCFccvBE4S0YNT9d/q6nzwwScT/xEAZwV0+GCPujYewOMY+hZJsKytzGiMf/RCsVEe7NpC5BHaQkT5XrNFCU9fS6ylvjJF3kTdYP3g2LQ+RM4ToB5VZ2d2zOaCLBpOScvbFeeXgI+SrYyA+8xhTOT4RCcNGHyWMfdgF+7SBO4pBe6nr8oM8Br1uDx92kEyw1R3u7j8YYa4CdIGTW5G+gT+6xCp53Y+zYwTtSzvI3zd7Ks8VYNPOdC2b8jY1qgGXF+K5EFnDBxOFHMMQo7C3M4Zhu9u/kQv21VYj4IU49+D+4d6kaIBnwYiaL6rfHoZ9/ZVbm2mZdvQlINFKyPeI5fr40w+l5ft3NnRe9PUff/axtPydN2Svmwfe5N6WbHE5915dElpjbga4tqrG4yQvO/8wrw7AfLVFm31YyedGsqmf5IFqwnx3u6HYtgW73wYtzfdydcdSt6dceJwwf9HzmZ2TvfXikiyAS+gss3OqA7acalV5bIy2eOKwUErMYSKilCLE8DA7/5kWkVDiWJMzV2TgzXYvdj/LsMf45kMZeT7LYyYZ5dCDHPKhjrg/j+eyPzzX62CSPAinomcfrHEFeU+9Er3EOi5mbz9yQH+UgOxr9X/w7Y02+3/0l7t94ed+WhXyzCeQB/KDvvp7/2mDKz5bz3qN81HmEhxSpnxc5JwlxEKWgzpC7lLlWkJb41mtBmwdOpG75qExgXjLuYriWw3IQ1q60zZ937p9DKzIGPMC3tMA+RDXYlcWj6TlxoauKwesIQklIy6oOG1Djaxc1wcKwEP1utpeBZKwvqgOWMUa88ox1SVz+Q7wSYM+1oOQV4yRbzc2hGbYXNO42MT410fePsD4yiU6zllncrv3hXQ8aACROsGcLM/nkNN9j5FPzSNOFdHRqogvPYyvHU/OnnfWpDk3zc51p1Fl1F2MfHUG7yKO/azmX+v3mZ8xH2FfycYusG8xx6kAbXDg6Jm0fOEdYSBOflT538Lybo51/E0hgeZX1UG+dlXHW5rXWmy+CkQ62vXiMbXBS80DaflYXeiJLgL7TlM5WRV4mvstHefcE8KuHz6s3OvqNWFGSkXV8anjOu/Bg8rhOl21+hLyrVZTfauK5/bapatpedDRdTaAagpLynvngbZYRc7X6+u8fVzD8T30xGSc/ew5QB079bjuI/doWq4f0zPuz6lf1gPFxMISevsq+hDmhcEy5jwVxaN3dlQ3myUc566OoxnH9OipTx5Ly3cvC5Fy46L6HJFGFNf1Fg/o+RbLapPNho5zf03lxIOldNf7MB/MWOt00mUfZp3vJZ13kLqnGItHuVz22iwxKr71Pl4R1/wfP3siLR9bVr8k8velty6n5fubeg4PIq4tunkbcTXY31kX0HYHSc11Aa4V760BzeiVYpAvZyeOeCUbjHo6UbOoeDSaQU5SwHvpAvIpoLYa29q/h/fYO9taC9jBuN/rcq1xusdFX87tu2p3upj9YeeZetajC5g3bW6rTucXNSasr6vvEusX763dnDpxIt322gUh5mZnlOc6Y7TTNvHOJvL0+Ul2/yZayIdH41jf62Fswxxqpa689PQnPqHT4p3GAOPTGPn+CPi3ckVrMUeASB0ONPYzDh08pvjbu6I1pjYwRQ4z6/3ioIPUyka7+dpT4sktfeJcoe3BKjH/Cp1FggfA3b3vHiaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwm04+g3vPnwHQgSPArKnx5PZjg15j4QUHQ7upbPJWSvqW7sqRvNHdb+kZz3MSvTyv6BtW4jm87wdkkyak8CvErs/HuxSVwi+AvIfirB34rjM4nMb5d1N/R+e/hm1cDXiPdZvhLcfzioL+hb3wN8ZV899v2kvulJs83XJ1ftPIbo3Bxwa8ma119I6+I+nkHv0Zqresbo0V846qAb9rD6MO53/1fVL96Sb82vnJH37IMc4XMz7EK+P3PGM3T+Uaex/WH3zpL8O0/PJ6AP4Bnu2g1aBM0fQr7sBzCrxidn7o7jkMQ64775/QNwyB0vmKrQ07wDfRE+8SllbR86rnPpeW3L15Ky3f3vgGawy/3+G17um1M8Itd/BDI+ZV0tYRfefOn1GgPA3zDN4cKwQ95gxw6ziy+ujkHWxk6zIxYRuPnL/r4C/gKzsU4FAX6Bmi1DIcsHDPPX3A57knqx0sVfSuyjuuvl1Xed4fp9nX+0PMr1xjfmn3rglwGnmncTcvF4qHMz7qNjs+Z3wDlT6P4E1Fu97nHTJ9cBxiMi04swv6sC9dWROUku+6odlvjZbGgtuT8uoB1ij61/23o5AHO4zrJ8H88cdcxB8p2RyjiF1ndnsYh/iI7jni9OCsdAYbo3/jVCF1O+H1fJ8bAuYC/bufT4jfLfd8C92k0Qq5CR4z9e2Td4L75ixC36Wc/10nCX/KyPXEs8Dk50Rkhu25GQ91HoUinqOkT86fQsSTRs2sN9axLJTqV0NUH+ZPzC3T8KnWIfCRRXI0R96p15bp5fIO/hJ+wDPZ+/RYOlCfFoX5BF+Tq2Ff5E3956jgSIVGfO65fqq13Fb/v37mK/dUXq8hj8xj05ldUZ2FO9zro4JfK+JUufxEz5i8yyoiPI473adH5JSp+2BhMcI+z8zpOsch2q/1pEDDGmDqEs01/uHv9uG3nl9UFWhMiHg0RS5MBfv3C2IGumMfFjNBG+Supe238erCAX3eX2I5VdELWFCpkbskElHm/M6DQPY7xjfEwO6mdePKFEJ/N4SfZYZD9a7z9dtLDr8bpHHhgRb+yO7CsX5lj9+DOun6xeRoOmTm4nW41NOY9cv5cWi5U9Qu29Q0d59HH9evTN6/JufPQjH4deeCAcvCrt/SrqjMnlatxDOsN2EAVA6KyflnVGylOXbmL+IFfbZXhBHe4rQ5bQbzbbmnecB/ONh3+8n7vGTLPDeCiMAm1bxlOXGU43xQwD6gh9tKVhO4K1bLyppVZjW3HDiv+5hwXO7Sb6Pv71dEPU3SKdV1cPD8NpEODx9El5Gc9bjDeMqvOc660qnntseecnmt0VrQcB7n3P79TZqzN++rM5x7jOY7H8YYuPstIA2bKyGH6zOd+8Lq1sZv//cN/pHP+T8dUPvyIs9gkRZ5+4HNx8TipeY1HH6A9TbnBaHBg8XxabrZvpuVuXmttvZ5yrJ0durRgDSOvMaTfU8OaLWfbEk2Q9/b7iqutjlxOclgYCeEOs58b5+m4SbffHuYLWAOm8/Dmlu6VawCO+yXG/W5D8Z7rFoWSttfnuE6rOJ3r6rwLS4rxedxfzHEfri9MN2huNzujsX884S929dlDxzXeD9o6UAdOP0kOa85IHBqbms+v3dAzCVu717kzhKPLhMEMLsdca2LejT5UgwNhGc6OeSe1wjPB/ZVxTBorhjnsz8Wyv+E49W+rb37pT9IynQPp4lDguwCM+Y4DPMZC5oucgyaYSNIZYtBXu505/+m0fPPOV9Nydemgjpl7LQiCIDg6+4rOj2v/0ss69tMP/XxafvuG1mJfbuuX9nRcGDeQ+01kxXnr8ltp+UXU2eqicuDion6V/tj547g2ObG/9O030nIf9qHvwCWmPvdyWv6JFbWll96R+/g6+k19WZ/98y9/OS0Ph1zrzJ7bP9ia17vX67gG5XPt6CJvfA3L6UcRC04+pAH+scPKrwtr2qed6DhbcLilk9jNdV3jha+pjv/V51WXMdaSf/W//F8yr/mHqaVjyuNLVd1zG+9iBnD76Hf0fGcWlbuffVrOZPdvKY52m4q7fOwcU5mOsE/70tv9Aznti/tyO2ME3b6xNhFj/KObt+MaHvNcdKHJvsizp9Qv/9Yv/lxavntH7W1pVnOln/zJj6Xl//X//L/SMudtvvkO7zePQcdJG5z3hVxfxb3QVYYuHjh+qbJbpmscHfgmAxAFmhj30Z96IVxiYs23STihoVCrqX7ZamsePtzR++0uXFAbTTg8d0H6KEz3uOg+X8bObKcVKvQl7Inn+aJxjAZw1sN76Fpdjrbr61onbeEdSGvv+wMnjp9Kt126LPeji29fTMtjLLyVy8pk2Ec5v4+43oc2xjulCzHbDN1xinBJ68KJLOnIZWiIXKozBkWHjvs91dOwj7aHNeEoVt5Ct5ReT214ZVXjz5h9q6TY0O0q/iaed0GKT1jD87noOp/L3h56Xl57V1lwoB7ejXfwbqlOB2vHGej93+uYY4zJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaT6QMp+2KMyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk+kDqfdEKRVhKRiM4DdJS0rYyo0C+FDCgrhYke3Z0WOn0/LmpiyS+tuytcr3YFEEW/+gDJts2KlXirA7bu9aqRFX5Fgm0isTKtImEfc3GsISnZahQDqE9N6HvfwAvvC8HspnT+XgHWC9Ngpp6Ucrcn0ynsjOa7mves0BN3EXfJhFIGrqsA3ujbNtlAp51VU+rzYy2rueLVil9lF/5WK21SeVwMKKeJ08vHMHaGeOtRUskhJYGIewEo1yrG/Y/4+yn8+0iJZWIWyyAvZRWlYB4eM4XEWqmCSS9bmD5JigbU+AB5kAi4V2eOAx2YH+5K9cT8vr/8euLd+gLQux3kDPjjWeh41gH3bqTVgAD/CMTq3Kai3vIFUQI2DfCxfKYDLSNZTQHg7PqF67uLiFij58vwlLNligFVFehl17s9XHPjpOtaDyDOLXTEHHARkpqOCzY3jaVorAKuEDxfzudfZR34wjjrVcUZ9bvy8rys6OrEyLy7QCfIDvU3pQcInz1D2+alNuU0/RfpMICNpicsyJMC4mRDJ59s8BuUN8EpFbI7T50GNVvm8lR2QF7eV8osXdEFbb9LuLwafzWdLSxjosK+446CLHnpQoFMWjEuxqkwnrW9fgWHc6GDkOCgH2p51pdv25TRLPHM+K42Li2FHu1322hStjrzOGsf4w/jkWjmPaxWYjvti2konnmZCPSURc5PPEnw6BCBJMUC998PhixHj2S+YXxHglDtqH9rqq63Jeba9YgHXm4gntD4Zjwjw23G0nQ6SiO+uyur5/RXaQr16UpfVKTedZWZGldVyRZSTvr9HQuPv/fflaWp7BmPGpHxfatF7TZ/NoA6MBbfB1zSXkVQwlxK6y+YwYPtC2SUEbwnO1plsMytXsvsjryRO/hv6F8JFiFMtl3h/vg/Ecl+vY1CNeoK2QaAA3esdWeNuxx9f2w7g/fhakROd6plE+s2DizhI0FNr3Jw5uMcjczjiZYKxlzAwxJuSdGM/ch/ir3QbaQxsf4gEs1DV3jXAtc1WNxeWiHvyJI0tpmRbAZdi8X7spS+YQ8876nNANV67dSsu0xc0jBzh3XHb7cwvCKi0v6ji0riauIyrIpncDttDXb8lS94VXZUW809A+M8A5DTHXm63Lln+rqRi2dh/zfKCU9vMfxlsiDaKxjl2DLW4ZeL9iUfXRRx0PEGwqyMeZLz966lhargLVFDt4Ws4RgbKL3nPp5IevB8EeObgplR00kQ9Z9CBlpg4+PJKzT8a2LNRS4Fpze/Ug185zeTBMzv4FT5nBhschSgm5ijuF0meXjqieDi1r++3t4G9U+838ay+p3/z9/0EX//d/W9dy7DzGSx826v2Xtfw4JC9KiTwEbJ/yn/ctzwtvsjQvK/h+X8iRjW1hT7Y2hDMeDLXmMh4lmeVJSZV0cOVsWm4DmZSEygWbO9o+wjqmO/XZbQf1SOuHs3hGHWD5xkCksGNubwPLXtb1DoBhagKfNBggZoNHPcZiYb+D+RYwSeUKsEoYL4l8KpNxjUbGNV5iHCYBMIEzWJ+C5X8OSWce5VJV+7dgZZ+gfvKYy1aqmhNvXWzsXbv23ekzniNvokU8xqo6kt4tdNIG5iQVcMq7GACiSJ+toS6rCGzxvI4Z416jwnR3xlZHeQyHyCJZ61gbY85N9ECMtQTiJnKRb1DFuYBXqJQ1yfmln/2ZtHz/0td0ncVXgyAIgp0213RVfvyQrr2zLZTEgarysZv3hOx87uFPpeUzTz+dlv/wr76Ylvs7yj+Jvuj0FUdyTa0PRiPhbOaqwjX8wi+d0WdR93fv3E7LFy8q3jUUEoM68DqjCdc5VJnHjimH6/VwbWi3m5vCVjQaXMPmuwYFtxMnTgTfq3JZOSfXTnnsGuLjafS5Yaz9r1zWfW/dupqWD5wQ3+rKUG1iC1ihUyuKR9e6mPNjfbqNHHy2pLx3GtXY0fMqlfSsH/1xPdN2E6iVLpAgQNbOLuhdANHKEThzzZbGvMY2kOror1zLddJkBIH9UujEy+B9VcD6/QTYHp7Hh+iiHBIqEUv4j6NHhZZ54Q31+5dev5CWTx5UG/uvfvNvp+Vf/OlPpuX//ff+VVomfooYY15/BehPF3MPFA3n9mF22UXIY314rwpjJ2/UeVaKQgh/9pf/A5xTffcrr/3rtHwdeVA41kE7ePnT3gIysiWc8BCYriHynzGQb8wHHqSNTI1CTwLuwVr7Xtc4ryJQ5trizpbqdDRim+Hxmfdq3Nvee34PnX4o3fbQKbX9b3zrBR0PuMOlpXej8oLAjQV83+qsuzn01yRze5Lx3iUIgqBY0Jgwl1O8u7umd6Yxxuxzi1pLaje1Ptzm9wqIccT1E9u0hONQM0BS11BuNDRHmeBdMJW+e/E8ZGetzveez9eGwux3jcydecwEuUGro3Unvo8pYc3oQd57/Sh1V5PJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaT6YFlX4wxmUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMn0g9Z5+wCP429DOKKJVEBAGcIUOoon+6MKCuATb6bkl2T/3qrK6CWCpGbVln9OPZIMXw8Z9Bo5x4eauDc8QPuVj2A2NgB6g3Q9RShQtmBwboDbRUrpe2vPTVsuHFgkewI6JKKiQrqV4JsQknUlkJ1SZB3qiIovt546o7muw4tvu6ZjFubm0PFeX1fT8kmzYijXZ2K3d27VOvXDpZrrtjauycruzLttB555ozQZLuBj+x3l48tPyyrFao/0V7FcjoA4ce2UVg2F/ylFKsGMNySeAXZRTpi8u2zAsHsOAHYf8EVlpBWNYaY3V/5KJrLrCvGwdjz/7ubR88st/FgRBEFy6IIzDADb2RP/Qbq/RV1tud9W3mh3d01xF93F0UbFjBliwFqxHc7i/YV/biV9YqCg2dWm3jzbWgjUvG1DBaZ+6ziauf7aqz84AX3R2Qc9hCX1x4vGUduzTcF954Jxqe1yHAXgdPcRV+sMRSRMAEzHsyUY5CMjB8OBVHJe07BgXOsgE7sM2Ot3MiF6fFqB6dgmHBGI9UNedvuwbC3m124LjtZjtQ05UziTJbhvEGo0zrDm5KfY8Ro6LkwltR4EK8vkncgyj/aYHlTHBPQ2IJyTahrgl1NPYi9zKxq4k7h+6BtzjhAg6nCvOKTY4+CwHZ0hbQ+Klkned30VeZV+711Oe9s5EIz0I9sjBVXEzLL6dXGi6+yKpgp0RYifGOeJE+kCmOAgWYnCc42v/Wp7PF+0zUo5VWBAqdNSRlfwQsXewZ0PfgU1ymNf/v3xF8eUPviHr5WcP6ZyfWVT+tros+9A4rzyt1df1vn5L5zp7EHlvXRaaIez2mT+HwIPmIrbhtBiMnPiFOnZwatoDtESm+0EJuKia0k8Ho0GnzRHaPxE5xCclxHnm9+9DBwGNJegi/+3B2jWHftBFAykTO0ZCCNAhILwE94GJnS9l5/4lIEeZAxSn/GcMnFsRRxO63DiIVsOwTMUcKkmy0bfOUfBZWlYnLGN/xszB3oDYQxuZn1EfGsE2/dpt2dk+eu5EWj5ycDUtd3rqZ+vbGusHwNK+fVUopf6AY5WCWa2m+LWxo2PmgFIaDbT90JLmYRwXC8A1FBAsW03l8jdvyb/+zUvK1e8A79ZDzjxBZ1zbUIxromNsbuneiVIact63d5wwybbJZx5SBn5xdl7z2BxQvi3YpfcHimWjofKss0f0rA6syGKYYzftuSmOr4l3/J4SkVXMayXpwZdyenBLD4Qd8pWJ2KRlfRayyIMxSh7kuh7knnz7s0w0EtMh3reDUvJdW5K93eG8qVwHPvDRk/rAt0Wb+BsVY+MX/gq25b+tG/97/4Uq8NFn9Nn5VWDQiI3yrTL6nqGHKODkXJwjTnlX7HY5pyCyTRbwh1aUN67OPJGWb1/9io4zUhytl7TmUgNOuxYrlh5eVaw7fPhoWp6FbXrsLHvqOo8d2R1PDiw/km57+rwwTT1grZtdjUM7QB3d3dT22/e09ndvU2NPIafy1o7GEs6ruDzRaun4q4eBN8EYMkFyOcR6TR7tsNvRvTLFIAooRF0Ou2qgs3WNwQuzqkvO87sdJaCY1gaNFrDHnC9iHT3cz+FxXSE7iMvTSIt5VFQR89Uh0D3zuL8JjjkG+qI41tg5S9RjBbnoI7rv0Zr2d/igU6hmW2iWWln1EiKA5xycKu8H8yDUlztDzh50iIEfIk8eYC3p6JL6/ct/9S/Tci/cxVtudoGtnNWxuzvKjb5z8cW0/Gs/IUzSkx//GK4Xc5/+jbR8Zlk55OvbvO/swfPOXaGUTt9T+dGPfCQt99Enqj31G6SlwcqqJnrvvKP57vq28s+794TcWD4k/O9HcK5KRbGVyKQLF4SQeeWVV4L302OPPZaW9/NRYlF5TuLi1pHnzgLtNkAu1kX7W11VYGgAmdce6znkdl5Oy/dC7X9ncjIth0ChEmd6Kp7utZtRF3lgVeWFA2rP1TkMUJjfVzBHywFLUipr/8VjilFra4qHfSLJiETyXKeDV97rFg52ieEY5Rri7rkjQo1tYV54d0fjYs9Z19dxnGVOJ60nzknjx0d+7Lm03G5oDf/5b34jLb/4uvrrv/6ysG0//dlPp+V/8gfCDjWAxuW7yQiTCK7F5bnc+wCIKN4L753v+hRz9fzikZ7rzzzz2bT8zPmPp+X2QP1ju/tOWu5f0Lz32h3NydsdHTMPDFMSIW6jHKF/E9teLPKF+HT3RXel2dcTgMTyJN3+aaT+KuF97Npd1Xsul42rG425RqJjbu/sjQ+YC5x9SOi+ty8JT3rvvsYPt7+yDxHbg3WI7GU655mGWLOaYIGSx8kjAb2B9labW07LRw8pZ0/w/ruHHLuNMvGjZeCgl5a0tlEAwolrpJWK4uzMjMaN9XXirdDOURFxvNtHEt/7AQ9uzcmmPO//QnfhILvovMpBnoX3nc2WYlYe+XDuATDYU77UajKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQy/fVkX4wxmUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMn0g9Z6eMt2erGjCELvCumaM8r69ThAEQQhLqcJElj3DobBK/F5OqSwboAiWjaUZ2St1J7fScqUiC6FqTsfs7Fn3TUa0WIclJiyaIlgj5+EpSqwLyw4ehBa/DnaFNuA+TJJnHw9GgdbiY9g3FWCd+XhedfDo4yd0mbBLOr4sC+oZWICWYfsXgy0zgiUp7eRCWGGFOG80v3tt7cM69k5f9n+0Fqe9vWOtTKtnWFrn0f5ix/LKc43EgDm2dNhOq8vhdFuAbm7Icq82lNUiHYsdGzNY2Sd5WIbG+AT9jml3F8EjeqznG45ly5dMZHMZ4NmMurLhGnR240cMhgJROtfWhWwq5/l8YUeHZ90d6bMbwFCs1tV354q6760dINRgCZYHZgMO90Elz1im8g7seGdLus7egOwcFTvAdVQK2d7eFVg+Hl1Q7GvDgvfalu7x+o6eQ2ug66kAn3RoXsc5ubzX74lbQ10OYe2609GxZ2a0vb0uq8EA9roB25CDyMnGJDmImYDIMg+mzovImQ7tNGWfGkXyPncs4NAnGHNmwAchpoHuyGMHuaPtOdgaO0gh5zi09Hu33eEE8TLGIMZxzsFgePA8XiwQh0heI8Yq7l/APRGlRIRhAVbhCbBHyRh22KHaJC2t4zjbro/ivQ+BUqKNctJTH2Es6fVk00lbUSIs9p8bn18OvqOOhSPakGvjzBiKcQtWikWwVnK4FtYljxk6LAWipdBGwve3HfxhqjPE2DNBPgcX0z4QSyXES+J0+kgS2BcrOfigh9l1FxeUY+XrB9PyoHU3LQ/B0xnujWNl4CnLsAYu35Od9GiouDuZoB+E2n92VTb8Ua6UWT6xpOe7Mov+TZ96jlWw8Yxibgf6zEGiqZzPZccvWnHCDTTIlXU9M4vI+YA4IhZu3EZbRR45BPpoiO0c4/N785IY10IK1AR/0C45xvlruC6HAEELYLSn+8DB5nHeuRJiLs7F9IuPx4e+mxa1W3qoJdjUM347FADGNCfxx0GdeRPwCiTfJKxHbedzn+CgBeSaw73YkIf38/KS+nMPc6C4oM8tzCsHX1kV1uzuPdmpg34abDURp0sqv3NZfZ33dPK0rLc3G4oB8/Pof4j93Z5ykhFufKamOFFEmV3rWQAAIABJREFUftvckXX75pbK65vEEWmcG2EM6cD+fwvH6QBH28N4OWAdYp4d76GuJsyjoQgNPgYyiR22j2uhZXcPSKsC4vypo4rPVeCZnLUL5lDogFH8bjzi1MqDT/KhhhxM0b9F2UkFOWwwNfZdT/w9/77r/50AG2QK605e3BMxRsQhcVpDxIwPmcSyFzPF60k8+2AswvazpzAWMZb9O2p6zKO//rJizYW/p+2nT+nGP/dZlH9Bxzn+MPq/wtGDoa4gIlWd5zzlXbHX1UAQ5bPzfuYaufyhtHzyzL+Xlp86pLnGw49o/OGc7sghrfGFaFchBsYQ8XDY1bjRaymW5/eY7WFBD6Ncyl6DiyNdS+T0f3WcdqA1QZClnLn0pevX0/LXv/16Wn79beH9cmRfe5476zvEWNgH5imHeQAvethHX8S5qmXdS72iBLDd1vjD+d+gp2dSwtjVjzUuNTCujxAgr012O0kFWPBoDOw45+TEfGAdeh6ohzLWvzuYE9xHYEs41o6xngZ0Yw0VngfWZ4w5YjQ/3Unq2MGVqO44p6+UNBD0Yc3PeTTXz6I42/qf8ZOhq4818R5wuxUicXOa0yU7r+4eA3Oa7UQx4vp1rcU+fkr5WyknbNA7r76RlkeJnntnrPLlHbXHcaDnPknUYUfIh5ZWgRzJafvmWGvA3a7ywD76ypi4M9R9p6t3TltNxbsc6hjNPLh48WJaXlsTnoJzDmKQKB8O/Ktf/WpaPnHiRBAEQfDyy0IavfiicFVPPCH81fKqYm+ncjMtl4EDqqDub+P9Wj9R7E0mqrPhnPYvVRQ7Do8VKwPMV1Y/8eG0/OH8+2Nof5iam9GYUChh/otxa3YeOTriXqenNrm1pfcI3T5QflfvaXtTdZrHmOZMNZ25Jv/gPPXdbYZzzhyu8Zmj6s+ffe5TafkY2v7lu2+m5f/5+efTcmvId5Y6/vK81o+XFjXucq559tixtPzOqy+k5WqkOqgXFbNfellj7Wc+cl73wndIHpwMcSg9YPQS5NJFjKOLM4orZVxDEXPrEraXsD0q7z7zUah4N5to/f1gSf3v+ee/m5Z//8//WOdcVHxcqQhHOQDSagw809yC0Db9vNpZAdeQzxPfkv3eNp72xRsfjpSIK0zGfOv/kbOmg/fcOGQhrwZ9HyjmSk24T7Y3vt+IsW7e2ENvdrGYuLwsLNFDDwlVurGl58X3vhy7I+aE/A5Akp1z8vsAiYenlmC8HA51neUZtdtPfkr4suvvvKrz6ojBGG2p1dK42GhoDDlx+nharlYVN5nzBFhDK5XQzufwThn5T6+H9eeMtTs+J4ZG580e36N48ElsgC7WKxvJlHgCN4/fxdpQp0uEpr5T4pM5xphMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZPpCyL8aYTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymT6Qek+f/EEf1thF2U6N8X0aBw9Au1dag5dk69OH386Y6AQii8Js5MBCIHvpelM29VXY1V7r7FoFjSc69nDMMuw0Y1qZ0i4p277HkYf8Qct3HxLEsSXzoZRoDwR8Ug44mXMFWaM98qTqZmNH9kq5W7I1zN+Wvd8mrJNqsCs7eFjWYXMnZMmWwHa60xFS5941HfPym5eCIAiCF6/LHutOT7ZMI3gg0nZ0EmbbcrE+4lCWVwWUR7CGclBKtGaKaHmlo7u4Je+Tngp968XX0vLBA7ILO370cFqenZ9Ny1FNzyuoyrIwQN8KwjiznDi29rDgRZ8KJrKeS2KdazJU29u3Sh+hnmmLFjodQdtzuJYSggpRQBX0+T6sc2eBUirRGY1+hLA36wIj1IcV/BjtoQiLteFQ2xdrsiIrow/RzrEOZFKpCDveqvrFBpBJr9xW37mwISuwHtrzbB1oOljGt++qXzaau59drOq6tmAl3EEcmUXVLM6oPm5deistn/iIriuM0Z4cfJIHjUTLOfZXD9pm2r2x52eX0vIA9nj8nmmMNhM7lpTZsY52dw4OaeKrU4m21sRKOBiAvX7sxF2PxZ2v7FgjesatibN/9vduXQyU2mRj+35aJtLh7NlH9FnaIMK21LFzxGkHA/Wh+/dltXvj+pW0/Mbriq1Xr2r72l3lGN224loXvqXEWXAI4TOf2euvj57TeBqDE5MvqT+dOC771QMHFdsPHpFN4vy8LEPLJR3HhyNhfYeJx+rSeZ4/Ot+XDkPaOcMSHRhG0gzyzAWwP5x2g0NVPdPI6QsYL2mTXZS9ba6kMvvxCLiQ/J49eXlWdpqDpvK0owuK2Z9+VGN6YaLt1TKwmMtndF2w6l9aVU74icfV9mqwqh001M/Kq8oJnXE/ZszQLkjNg7ETAxwunIoIZSGwTSWgnQpALQy7QLnA4j6kQzT8PUcOPhXnwmPbx604106bc+CYqrAHH4IbVQaKA7QZx0p0E8NCAznDkSorQUV04++xZdVBG4PpzlHbHd00Y0sOfJAwj7EwyM7/2G9i4GsmfNZ4aIMecziVYwefBAxhzHF393rqNdmrVoBK2FoDagL54camtq8eEJ6HtrsRUKVNIDLH9/TZxVk1eOKKrt/W2FMqIIdE/97elrVzH+NQDbjGCTrCAON9o6FckZ8tE2ncxPNErtanPT46QH+g66FFcRHWtQPY5u+P375xi619gOc6Bu5wBMRnFzb8Ea738JLqY3VhMS3nMQaPmbuifUQexJ4zz59GsfI86KLE2c6EAf2SDuDEF3k/m30J7h/0X86Iab5UhAHWh97Jplr48UwPgori9eSyr92xf+ZnHfSSB+FEYf+jx7DuE3PM+Xc/P2J6uN1QH/7OdxVfXpYLePAH/1Jx6m//x6r8X/5VHWjxCOaCxQe4Jwer5fH2n0LVYOndDBUL2f9CJCTMkxpA6Lx8W3FscU4ffuIpxbFimVb+RCkBCTPCukJDuInQsVzfLYcOBpmxEGUgTAPMyeIJcPdI2kaxctqlOeWxR5YOpOWPnJEN/suXNSf7y5eEh7nXgj0+Lr1QVp3lMV5OMPYsAtFBPO/mtsbp5SXlw3nkwF2imlAnfeBSx8hPuhi7arNALANXM+7p+Ctzu9ujMWz+B8AYcLzE3G6EseoKnuWjI+B1Ep1/FuuCTeS9+RFQjDh+lajgVeQtyKXjJSSyUyjmdvkc6pd4Z6zTEbvAnJMopYKDLczGTVDETObHatvD/rm0PLeiNY+TH30sCIIg6PdvpNv++R/+eVo+/vhPp+VPn/o3afmpx9TG33j7J9Py1y/q/C9840/S8sFDqo/Dp4W1OHQUCLWC7rUGJM3hQDHl8rUvp+VuhPWRmvZv3FT7ma9rPa3TEfLg3h3FpnJFAyNTr+PHtS5CHTmiue+f/umf6hq8ax7SoUPCVO3jOK5c0XOam1McbjaVRy8u6R3Z3TvA0JcQe7d1/s5E992INS40Qx2fKcNiDWvSyIVOlVVnAdcFBur306gJxvB760JJjRGP5+fx3hH9r9nQPe+sKe/fuKk5yGBb7TyHsTCHSh076xM+POO728kY6+dEDp1Y1LuZf/9Twic98bj69hG08Y/+zLNp+RLeU373huZ/P/Xxj6v8oY/qXA9rrXBtU2ub3ft67jnMj37hSeHZjtQ0tn3+yq203GmpPRNxRoWet6Jj9CfG01pF8+BHT6vNF7EWQLxxqcSkWcdpJ7vPdnOk512aAIeUU9uvAnvU3FJdbg3UJtaBSW9jfadU03EWFk+k5Z1NrU9P+roGTJmDHsYFLD0Hubwv4Z8OOSu+zgSGSWo2+sbBLTlz+TBr7yCZqP23sPC6cljPknmbg5FFP97H9LXaetaHDimHPHVS/eP1N4QL4/oBu3aMdapJiPUoh11LXlD2O3pnb/SJzXX10YPAoG1vau230VAcPFjXONAfcJ1D7bYBrNL8gtptLscJL4U4iO9uLGBMm5nRc2ghHoyHjI+7x3HGU77HxyDtRE/fvDr0xV7PZ4Ps+uYuI1xDE22Ec2mffnTegJhMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTN+H7IsxJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTKYPpN4TpVSuyHImDz+jUSJbKAdhAD9LIlNopZ0UZKsVwoJsTFsiWoDSvikni58d2Fqvvf1OWr55e9daaAh0ynBI62VtL+dwLTqL12KP3yPiPsRdJC4nybOdJwuzdne20870YCDrpIOnZdv2F6/KLuydK7IYJX5mBviW1QXVw5GDsnV6eknP5KF1WRneh/33pTffTsvfvCTbtsae3eewoudUnNU5gx4s/yCfNVvkbIY1d6z214PtnmMBjWYTuT5haclBhrxnT/jh6wt/Lp/ipQVZoJ4/K9zGY4+cSMtHgFiqHIStVpEWVMAlELHkc7qG3X04xrMM1Qa2rsnqdtDf7XdsgwU81Dwsraqw5Zyr6Pm2BkTD6JQxbLs6sBZbqOhBPn1IVqIrVd1fHm1gOET7wQnimBa12oUW6rR7y6FchEdyiHufndVzY19/655s+V7blLXciHUF28GHTsvqc+PmbR0IFo3Nvfi4WsN1AR3Sgi1aE7G0C1v9m1eup+X+lsrFg8KtuT03O/Y5yCQfeil8t03btKoItAHteIkRYpnWfSHGnMRTX5GDRtIuEZggHHPGQCaNA9oa0gZ4d/+Ench5FEQZZsdIF/1EhFA+c3/enw/PNEL/+6f/9z9Ly1/8oiyB/+t/8N+k5R/78I/pGnD9t25dTcvf/MZfpuWvf+35tHzxzTfS8saGUHCdtvqND3NYLaHu0VTbwJsUYo7ZvMfd53PnuvKUlRVZij770WfS8le+/Pm0/MorF9PygQPqc0ePqP+fOvtYWn7yKdmyHjl6Ii0vLumzbENhmP2sQo8F5lQqyo4VcaJ2FSOOTnBvzR7aM8a2LtrVXJFxTOVeX320VpY1fFyQJXKupLyqVFN7y5V3x4FiRePBqAcMSF/Wms+clTVooaTzLByRLe7MgUfT8qAru9dDp9U2oqFywq1rb2p7DFtR9MUIyDval45hlZ+LVVEcW4bDbKTRGDltFfgkWtFyThDHuAbGDzyfAWzf4VgfRLTQB9qwvPc8iVfqtNGHI+TyYz57HBv5ZB520F3Egs2hzn+orvsA6THIwV2XNu0YXgLQs4IE1rzTqDrwnbk8x0U8sDFzTm2OOY+MmbBzLMrOBXsdVcxoAMwB2ky3q33yqOD99jNEQ712W3313oasZFcW1V9j4m1pd45YO7egvpiPr2knzFnOnT2pa4TF/uU7+uzxQ8L/RIn668am7GGLBTWm7R3N1dhZCqjXVlv1QZRSjHymWFSuMsB8egQb8XZbuKUcrqEYq1P3ejoXx9R9BGQUZf8+h3jJHnAkCRAdxGD0Mb9cWVDsfewhWSo7uL0R2gpzGzQuopy9c/hplA+l5EUsOYkm9vfgizzoJdIGHYahz52bn907Jt24E+/1esp0+/a5SU8898qTOdgeftiDjeL6AZY8nOPkPNsd6fggZgZFB983TY0PeS7G+jffVh/97/5H/cfzzyv2/tbfVcU+8VGgJmseZNf7X8JU6sxY6yMvjIE+9WDCtjaU/9ESPaxr/Pmz11S/FbSNJx7n8XXeBGjfVlPjwwRxlYjB/XDInNeZOyIPTDz28uxb+UDjRBn77IyVM0TImWoDtZMPnxDW5ewpIVK+86bmR3/+wku6hBDrvX3F+DIQDbRT72JsKxWz0UvbTZWd5QlMBvs9YgV1zARr2CWMJ6tYd80nurZeZ/dZfXsTuFGuxTt4cWAncVk5BMLyjM5zAAjT+5HmKrfbPI7uo4ZxsV5F29pBLkYEwbXpTlJzyIFiYr+Qg3C9ssW8x7c+yMAHBAMxoBxGeZxyIsTDpQvAc546m5Z/7NO/HARBEERAUHzh2+tpeWNN87nkqOo/ToRuaHW/k5avxepPW8c0dzw5r3X9lWVdYweoNM53lsqKRw/1gDa9orlsc0V5YDhQfpjb0T4h+LkJ1pUGwJ7ksT7MNdsTJ06k5aeeeiotX758GcdRDPCtZzHX/eQnP5mWt7Z2583PPqu1lcce07z65Zdf1nVhLpoDJqmJtaYK2tyZRbWhqx1MBoFQC24LZx/O6b1Kt6bj3+sh1sxovjIYan4wjbpxTe2z39FzHyJmb2JtnBog1nY3gBa5pz6SJ4aX0ZEYbMRvzjeIV8ZUNs3OTmE97hc//VNp+XM/pfL5jwl7lMP4G9y8pO0rK2n5N/7T/ywtn/kL4ch++dd/Iy1HDcQgYGwPAPH5TqJ+85FPPKfPbgu5ffE7L6bl+TrwdyHjmgcXyxTYizfBfJ7zO4wVI/SFPBLoKNJYOHQuYbePFCeKO7lQ+cO9dcXEYKh3l+cfFibm0rr6RwNIYKLt5xeERp5b1FprF6jo4QDoS+TjrQbGAqyh5UiHmkKFAfM5rtFwfuRBHnumUA5RNs/6Ul46wHuoYlnPMsQCHb8b0Ecs7+0t+O3s6Jlyqale1fEqWGTcAT5+e1vrostLmnBFnkY+QRtn+s61KebD7EO3b2kN6Nypj6Xla9eupuUx1koiNJqNbb3f327q+rmGP1PX+BAjv00S30RYqmFusbKs7xVsrGsdiuNutHde5sITH97I82ov8bxncEKK056y30YkvrcUWNMn5rTZzh5TKHOMMZlMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDJ9IGVfjDGZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQyfSD1ngCZEHaBieNpS8sxYoSwi4MIopWkjjmGNRPtthzLTlgT0lY0XpQFWQ9u8IN7F3aPPZG9ElFKRFBEIe+P9mqw26N7lOMJhCLt+bJpPt+DmMi2EHLRGvp0vS8Lr0Dul8GXXpG90mZT91gryxaMlnBrXVkhrd2UbePFe7LcuzWQpeAzz8rm+63vyqbsyiXZ1XUmsgBs7FnW12CB32/LroztI/RgRFzBjg11X4p1jf2xrLX6sFANYC0X5fFs4XTG55DEvmuYDl1bk/3T2obsttbuqZ3fui0L3o98WM/00byeUaUmNAPpSUEEm1T6Qk88dnoTPddxW5aIF771Aq5z95o7PViW43j1guq/VtI5C3nEBWB+tjo6571Gdp9eKCtGnF+VPVgFxyeWiOdtw55xTPs0dKIyPtsHooFGtgUHB6FyparOe2ddz+et+3q2IA0ENdqH4kw3gE+KcrLJnZuVdVx5uNu/DyzonEto4ustHfH6lup1B5aWN28ApfbOa2n56OrjadmxN0uy49cDlYmpI9YlmD6FaBtjWOXlYZM8GA6wXf1vggCUz8MyErbNbDN92MlGPA5RTcAJ5BEbafe730cSXHu7rTbY2JGlYKOhcqultjnCNfK5FIuKHeWK2uDsnCws63VhYCqwTOx2NZa89ppsha9ck+3gd16UDTBSgOBbzwuZ9Gdf+JO0fPvmrbTcH9HiEH16kt3GGHtGZDUhEZipAieDsWUwULlUwkC9d5gJLDe7wL+NuorhtaKu5sCirBFrsNLe2NC4X7mt5712705afvO1C2n5kfNPpuVPf+Zn0vK5R9SPK8D6RFF27jaNGo2y80bmC6CXBQkStLm82nNzBMt65ww6fn+ofaKi+m5pXrlogv6dq8luN5gIozXZs1nfuqvnWJrBWIX8bdBQ/zh8Vs/r6NOf0bVE7PMql2uyBj3yoZ/WNSIz7d6X5XQMxEzcJ4aN1qqOSab2QdtOYE8Mul8QF3WcKtpzTNQqbMlBOglI1+ljbjHEdU7gu5tHDgoH/WCf9oJQFoxwvCJQSmOgkRh3XCd97XO/B5t2NKJ6gZg8bXdQQh7Mxgg2qBOftfGUqFoFE8uJIdo87Cu/GI/1EEplxcswZHsLsL/un0hconqGsNol7ijyoDH37e7X1mV33u3qGhfquq6FmvpWDciF+ozGs6A4nxZPHIdl/ZbG1AT3vXpAlugddJZCCRiFgs61uS0b3RHGsDzidBfH2drW2LI0rzGY6K7+kNg5natc0b0P0GE6QFd1wS8rwf54MGyk5VZb18CYMdxDTDKfcvJJtIM+5sDdrvKWONR15fC8jx1S7D10QPGZFslj3BPXH3KO7zU7KeL/tP+kiGgkdiJfQu3zMvYgk7woIx/6iAExzt5n/3H78UkeBJIP/cQ1KIwlJF+AuBjk0I0jXmPBWbjIPi/yQIetRlSUh8fnIHXQpws1zCNzzk7Bj5J6fV3vF/6NHsTbb+v+/vPf0v393H+oOqgtI0/nGo0HZzONOjPU2tk3IsV7Ym/75EBCUU65IPE8Y7Srz7+k8aqUaO7z0Ic1fyBisNcCai/g+u2710OdNU9+ysEqMX4Td4jt2KccKpY30P+aQOQNx5rr1rq613pVx/+JJ5QPH1jQvX7tVa1B7WB+WQFKvgOMwgBrTGNcc2MHuMEOEQlEsADLiHGUxy+Cn9nv6DkMkWdEofY/urw7b57TcB0Qy0BkL0MQEUCMFuW88rIY67XhNtCXQJbnx7qWKoJTbR7zjLOq7943tf432eGa2PRpgHcBZaAfOV/k2kAeuddkwDyJ6wRA2eBcOeYL3E6EExBjF9/4i7R88mnN2aNo97w5jCsfekxzu/lHtEazgLyuu6M8qYy50cIQazqh1g+/e1vIzqNHdJzZeUxO8D6mXlFsWhzrOIVI8S5/Q21pa0HXfH+sa5htqlwB6quAvsW1LObJv/M7v5OWx3gOLPP9D8V3Moy/v/u7v5uW99e8uO/zzwvPzWN/4lPC1jBa5HpAphXwHEJgXXqK23OYH4yqWP/DKjAxXUdXVK9Jou3Fms47jWpt696GwEGRkT43ozbQxYu+BHNzzou5ZjdEfx152gCTson7AjMtOXF1r/wzzzyRbvuV534iLR9eUVzMh0R4YSw89Yiu8d6NtHxiWf3vd94Q1uzMFcXX0wnmQdt6D/CNV4X0+qdf/W5afvhxYb9+9uNCOx0CduxxrEO/eUmYp2aHWDyuYWTnBKHzXhO5N8t4txRirklE9yDQ9bTxDAd7qMVKXuvKcagYtN1QPd3rv5GWhzW1s0pfY1hroHOWsOY2OyeUTLUGTDoWgXrISSYTfbYDRHEUEVGMCcg0CuN85EHccNbhm1J6lgeDAnCfHaA88znlJjm8pxyNs9eJwoyYffeu1r07XfUt5q68p1ZL4+I7QO4dOypMZxntgTfC9c/Ek+smzrqF2sPGfa33Mje4fVuxn1gzoosa21pPifluku9TZxR7IowPUcLRSGL9lIASJErp1m2NIT2gvvfXnpyvani++/C933JIr8u3j/OlC897+Ul2G/VxdRnb2733x31O+/KOyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8n015J9McZkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJ9IHUe6OUEqAeBrKvG461PQf79QTfsyFiYgz7vSSXbaVDm+zJCJgUWOnQxigEVmJmVfakJz/0cBAEQfDmX8lObAC/ThehkG33HXi2P4hh68RBhaDowQU5iCWUC0BoBMByvNXRPlVYyx6f13NYa6m+W7R/xHkPzskm++d/6WNp+fzHnk3LzYYsh46fPpuWv/gvvpKWL7z2Vlou79mhl2jBPaZvMW2osu/bcULyWGHRgq0UqB0MCZxB3TjOTHSAzT7VVKoDzE8P/amH59uCNesQ/a9Ykj3Xo0CQ5Uqyeg8i2OCH8JRONlBG5U3UNsZd2fvdvC78zubGrv1XjErfAkJktqw2Wy/Qylzl9abOcwkIqW04ttLO62Yb9mOwh12YkVXYuWO614URrPha6nMdxCO2PTqCJ2yTHsv/GhABBTyHew3ZjbbQvwPY0edhH0oX6VZL9ZCbhe1fjPvds++tVXTfQ1wXm3sDiLUGrH43t2Rxeu+W7N6OAt0ToC8GHitKt98zHmRbvLlGpFMoovM8bYBIApfAl+1Z7x+LiJUgugQ2obAa3NkSEuLm9atp+dXXdq02r8A68OoV/f/6mmz+mk1ZDQ5gwT1GR6NbPG0BSyVYYFcVR+YW1E4PHhWir4u2/9rrsr/sAb/2e7/3+2n5X/z+P0vLG7dkQwo37GCCuqTtYAEYNKJZYucBZVuojhBPh0NYaeNAY1qugt+zj9IqwG5/2FM+dfktYHbAt5upC68TwvN/jBhaTHSc1VXhI978rvrul/7kn6flL/+pkFNPPvuRtPyZTwux9NHnPpGWa/XptuMdEGWG/BBNMmAKUqQNOULXDJ5NDeXxmOMSsHgHDqXl+hFZuhdqaudRQZav+WvChG3e2bV8pSV0pS3LVuI+yjNCs8yf0vOqLKoPjRrCq/S3ZSc77qgf52CzOXf4dFqOMbCUcxrHx12NVRy/JyPkpYgHxCcNe4gTQJOVZ9W2I4xVEbBHI2AXIuTqTIfhvB0ksA6H83Yw7MPqNsD+ezinTg/3jbYyxHlKQHARvzGELXIbsWC9rfLhWcx5mMeivvsjbSeFaACkAdIix+Z/GuXk9Mg1eh21q80N2egWy6rg0LGr5pjqmYuh3O/2sJ25hoSmFBRgMzu7N0adPao5ZB85dRd2tr2+4u6t+xpnj7bUj+cKipfzs+pzD50+lpZbO+qvtTrwBLBe7qAtNXD8AXLaXKyxtlwiBwb5XFPXefGKcrjVRcUV1msF9viJZ/wj0WvsIK10nZyj0caWlvj7KOPQQeGwr6hjjrAmcP++5hhloFDngaM7BVvkUgGYWDx75i25PDo7czFOLoDJG4+mO0d18DzOnAXbsU8SZeexPnyRkzL5juOglMgvw/5ZiKUHQSZxMYPHG+qkb17U9s+/pmO+uYXxHYc5MKftP/W4jvPcczovSKFuEHLwUNmLRkTEuSk+MUzYn+XggyGu9Vy6qjj1D/5b1c316xrI/5Pfwpz2cPYa2s4d4EfP/EAu8weqo8C61zBXa070gIlmyee1ZkBHRfjCAAAgAElEQVRUfQ+xv4BcdAv94o9e1fa/taBxd2FFSVOCWMo26UzZ91pcAZjOEeYgE5TzCeeouqcR1wk8FuoxkHtf+ebVtHz5suajn/vYx9PyYzmNW0PMfY4fVLwn7uUbF19Ny7Mzys0nI9XxOzeu4Yo0xk/AX4vC7LGw3QYuA5nm0jIQAVjP6nRUJ0WMXRxOZvfWqmp43neRb8xi7B4M9CzzOM8E+VcRNvkToJSuj7C+jzici4C2wRhZBbZi8oLqPrmji49nkMhOobiWx9xlhO3EWpeKwDsMtX/oGaImRPhg0kJUQYLcqNNGXoUcZAYY6tFgtx+HOR3vzAHlvAW83/jmC7rexh1hJU5F59Pyr9XUTr71yrfScnMMTGdb/andB+YUnff6jirhyRPKvZYPqZ/t3FUMarawFlNWHQyxllzFnODAgQPaBxMz4iOIQHJQ39/ngj7HJaJZ98/loOM8ykXqT2cOHk/L63XVa+uurvcmCKPjmOsMaH8V4LRrKofAzcxX1Fb6W4qnm7npzlF7LcRX8G0XV5VkLR1Q+c413dvBg0AWHQOi67bml7feVrm1g3VMrBlw3WISZOdt/CNf2G2fd2LFudeBLJtgXX/pptZ8clXFzvHiibQcAY84unpVn53VPPLSzZtp+dCK+tm33hD26B99SfjAG2taA3oDWPlvvyy8+m/+nV9Ly7/6a7+eln/vD/7ftEykdx/jzHiS3a4iT64+wYg/wHraCDisIXKIAfpaG2tJ/b1yCe8ut7oaq16785203M3fT8u9kdpQF+h15ux5vE8uV4ik0fY+cFx9jAVFMFjjCHXWV3uNcu+Pb/mhyoNGSgLPvND56Pvvk8P8b31TuUyxjJiGHDgGWst9PUyE1W57uH1bKKU1tP16LTsXYW505eqVtPzIw+fS8skTJ9Jy5PDPcZz/n733DJYlPe/7uif05JmT081x792csIuMBbDAkiACKYCySVCiRZZNF+kSLVoqq2x+sMpyuSy55CqxRDBBzEEkIQIgACJyV1hgF2HT3bvh5nzOPfmcyXnaH+ac/v+amFksYIbh9fP/gvf29nR44/M+ffD/vY5dWQ35lzrysfW61oR6Vf0km9R7l5H38Twd364gT9vTs+WQq4+4g791hKY45tbwHwp5XWd2Rt8UisA59XbWSD+ELmZuB3vs0Act9JUh2K3Xs3bzvly7XeYgQ39joN92h/wtBmWOMSaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUymW1L2hzEmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMpltSr4lSisE6MRKv478ANxAlbgm2YLAMpcUkXIycCOySaHXdwT+StNuGpTutdPgMMwf6Fvfri7JUWlqR1RJpMBF4abn4GyEvgpOIr3BohQtLJ9hE9fCuYaoSXpCXp7UQbBjjLVlvrcNnc09W1l4n98vy6NtXZBvXhNVnEpZmR6dUlx/58MNB+eCxPUH5E7/3yaD8/EVhdB58WDZTY6ArTMjVzKnu2G5mgG+pbsvqLDLYtTVsKxzCiww8HLLD9GBfGEd7tmBP7MOmz4V9fQrd33NVr6Mo2pGzfTt4t3ZHfeb5V9Xnsxm1x/whWTxOjQuP5cZhrR6FXzQsuZwOkD9d2XxFY2qDVFr1uItbCVmz4T1AWXDasKZbXFefWSlq3mnCx9OFbSyRDrTqO7et533m6lZQPjCnDjyWUwfOJnTfBpBCLTxb6C8J0aFpC+Zi4HtAzXlgM1SBxuKreEP+VrE1BGPT2JJVYgkWwgcX+m1Iu7daU/ckLiCTgK0psEpVoAOIoAt7LvcGlzkPouyG8EnEKoUN/EZZrAv2Zx4P4QOG4JZ8n3XkDzyH6IEaLPdeeEHWmZcuyCLz5RefD8pPPfVcUN4q9W38QusN28gfPKcMaxU+bwg1Bvu/9XWtSZHL1/RcT8vyshWy2RxsV3vpguwOPay1idAz6PwYnppu3u0h+IMwugNjmiiz0FzFwQ4LXE9zCWOS3Qb1MZfGsD6tbcOWE8tQKq76KBblu9uO6D7l588E5fnrmvPzSdhqTwnTk8lpbk9GNbf+6i//u6D8ta8/EZR/4V/8oq4/J1vFUVEU9ehF2Z9V14ko7MuJPMBEmsS85Pc4dnXcA9oqPXevfjsnxJGb0NoSxc1yBxVvNbv9sUun4y6sohMZYZqm9xwNyplpIZCadfWHynmN+c1vf0bPe0DtlbxNttrJrKyHu5Oyq3a3xZ6IJGVD6sJu2G1ioLXVf3qw120BL5TMI1bzWK+6TGjdwBzQ7uqkzRJsOrEWekCz8jKVlta0VFrnFHesyxOMJ2mtzLma9tk+5xSdf2Nbz5XGkE96iDMTjNF0TgLIrg4sUTl1RDBHT4yN9v+PoQOr4WpFtrGXMfdXqopRp6YngzL3gsRKRGNqxy72lLRNb8GynusYsQ5hjInqPbczH87Ny/69i0aqAltHS93timLFc+fPB+UjR3VOEzjACOaXXFb76nYT8W1N1yzh+htbGOuIS2emgYbA2pLH9evAWJXKKq/imsQFEXGWTmsOILK1CnRVo8UYkftz7P+xXLYRU8bj/Y4eapuQvS4whV31re0txfJtoJ9uO6B97PyU5jiiJCKwzOYcRKwSUQrEQ8fwW98Hc20UNQSZNITkGcJUh1kn7sDjPtFIg0lYw+8bGXzNYBPFDc4wrBKvh/n7eZFTnP/pL3T8XBk4wCH7C17yT0/rwf7JVc0j/+y/xbw+T5TSEMwTM2zqqqH65tbHjTIWHfxst6K2S2qfX/l1jfVGXRX4M/+j2qSNPM5vfEzHP/Yrf1NP+P1rEqiQ2Z7m9fUW5iKMpzhzJDGuW9grgRruIl+54qu+PvOUTvqBe7V3zGs74ISx8d9pPZ7wtAYkkCOrtZRfTSeF5+76QC60lD9sIjf87ZeuBOVvvCgc7p8//kJQXkT+9rlntb/9t7/wPwTl2SxQDFhv5qcUP9+P3M3YhGLpWFToxK899TtBORLT80/qFKeF2KbXBCYQ+4PpfRrgsRAGUO2TB2qI51SAFYnvxDyc+srgh05MKFfHnAPRQB5ZssxhI55aQ67MjXBvqjLSu05iCzhfrPs+3s/f5neC0VPCUx8mWtwHGqyG+KYQVzAei3CsAB9F/CPO6SKO6MVV74mEajU39WhQfmNSSK92S/Fzo7aycw3FHEUg5r/9pPrm8pLadC6HXExCecINTB6JqsZoNi3sQ9IV+nO9AeQb8hMukEM3t5Traa3gOjXgZZEzjjSFkqjmtQ/oYb7J19Q+pTLxb4PnrBj69okTJ4LySy+9NPD8v25NT2hiffA+7bfX1jX3/sa3hLU+evyOoJzFR5Uu+laXOcWM+s1EXvv2F85qfrxySXido0eU6x9Fzc6rrTMJzZ3zB9Qf2ojt8hnNOZOzqi9+cyNCxEHfu9rE3pT4u1CMRYwr0b74Trmzx1nZ0LipIK9exXyRxfzS3MK6v6h8TQxY60NHtT4duaZ18Q//5PeC8uPY71y/qXzfMhBaRNIQ/3oZqKZ//+ta87bLmmuOHBNy7V/+U/XnxSWtx3/62S8E5WJJ902ngMqOcE+ncr2FXEhP7eBiHU0lEWc0mFPozzdR7A/iWc0jvq89bQx5oW5d1+51+N1l8NzBObyNflMqAmmM60zkgWpqaI6uVPVskfqI7xcZBw7ddwzehYS+fTF/zg1MD3mIosZCKjOL89lvmdcbnG/fxTzV6shrrAuh5XmKA3nteFz9q4w81dnz54Lywrx+m84o78vvWtzDcY6gWjWti5zLlpf1nNsbKp/DWvWeDyquvnD5SlAuldXPE0nNB7ksUEqRIe0AheN9vVcKCDWilG4uaw7YRXj6mF9CpHd0ItcZ1n6Dv3mFNaTPhf7F7zpD3jv08cpQSiaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUym/5/K/jDGZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyXRL6jVRSnGwTvyITiUSoA0rHdpe07umBQRLZIgNXgZ2xzV6ouP8OGwQXViP0gKtu2NfNnNob3As9vLLuh7s/yJDbH1CRAdYLPZgBe/DzsuHh1APFqcOrOB7uKgbsvXRMyRhCV6HLfUc8DQfercs+r783JWgvFkFLgAOQvfOqF5/7EfeEJRn9stq+hO/9dmg/ORpWcTF07KQOrRXNm+TwDRMbMqi8VMX+3Vb25I9VRjBQg2xyhpc/Ct1hrb3aWM58PJOtKf+mnVl35eKARX22kPh71zZpJ5vZVudrOPSdhF9clv9/NmX1Eb33i+7zsljsiR3k7IhdyNAKUVUR35XFl5uE7aYEfXP8Qn1md7OOO7Azpa2WsWq3qNWV/lmEbaycCgjnsSDLVmXaCnMF03Ux5l1Pe/NLZWP7pH9WAJIoQjsFt0BFsP94w6OD+7nnENp0deC7W0C9tkt2DL2gFfA6zoT6AsO8AItIADGM/02qcMCvwIsAOsslwL+CtbNLWK6MDc5XdjlRjWeaEfrvh7cEtYOWqw5/mDkzaiIbU3sA/FJtEmmTV3YYpIWoOoDK8s3gvJTwNqcel74pJWVpaB86fyloLy5qbmXbb/bD0OWdZh3G83QbKsSzu92B6+RxGOxDoa43TtdXJTncx0I2eXiOi2sqS3+dsjCwXoNIcsw5uJ4uExML1Zvw2o5ZJVI7ImOwy3ZieIhkjsonwwsQseBNKoCL+J3NMftQQwzNp4LylevLwflBF6qCIxVE5ae999/e1A+cFz4vCWgl5byihNOP/P1oHzp/KtBmfbEo6JYCNkmubBWTwJJxTYKBQycloBgicC6NpqTrWS9Bmv1c1/SOcB9xvNqPw/lsaP9PsPYuVaSnWYirTVp+sib9SxRtVG9pLarNVd1fE1rfW8Ba3FRNpgO6iaWALentR4U/Q7meKAAfCCfOH/UWxpPiZzKGaCUYmiHThNoixZjY1yzDltMYtP0BE48jvUemKJUUv8gyqjZ7P86EVpC9d/R3E4P8UMHcf1WE2sk+s14ErhDTBeYRhwPsTMxYE0seZk00JBtnZ+ND7YVHRUVt2QdfO2a8EmnXr4YlD3s89qIQWLAcdLuHg7bIZxBq0l7ZNraA8mENThMhyG2qV+OwTo7Cav7dEbxDdeqFBC/KxuKi69cFFapBmzQxqYspwvAdzbqshWuAZ+0XdE42yppXl/egMV+R888j33kWFbP3G4zBtB7l7FW0Da867C/qfIzwCptRNTODBDaiGmHIR4iIexAfxB6np4rndY61wBOOIoJOoHzM0n1m9sO7gvKSfQzxpw+kExc07sOJg/MNXEPGCbsPzrEyo6iEN/4g0OXMPJn2PEQYmkILmjo8e9+r5Db8e51wt7cziBhCXOKGzrnP3xdvz1bBh5x4FXC4jkVTOy/85Su88BdWjje+yFi9wbHz6G0AvFTOB56RVjAp7ANT4w26fmvVbUG6v4P1NARYLNrQCn98X/SWBxFlJLX0Jx9PKV14HRPcR7RxswTcG4M7zVRZi7NU91dLqm+vnJaWIT33qdYcyyr62Q8ofk6OwzaDvDcKU/xZCYqnE/U1XrW6ehdM3Fd78nTsoj/V//hc0GZ+7liSb/tIjZ+8azW1M89+URQ/on3vDsox0qa19s5vdPeGVni95CfuLyh3NeRk3cF5SRQR+kccUQqRvC+XbRDAsjyKJAaLvJjkZjOiYXQAWq3xoU+UmrrpnAac8DYjo+PBeUSELucNrMIZBlztYAYTWLdzyA28BD6J3HNBJEiWBfdqPqIEx2MFBgVEavYRjzJfBgRS13EljHUUafN8UrEm44TP9lEDJTCYpjMHdRxbE5bdSFxtnfi6oSrtt6bVyOdeJ/GwdKi9oUrj+sazy8qnlzGR4qTB3TNjbrGtJdQf+s0lTNOpIB/xRq82dX13/TYg0H52jefDMol4mcawB+W1SbXS+pLhw8eDsovvCRcUDarGPE48hnr69q/zs7q+atVIEqBfkkCQ1EHjiOb1Ty3+9vNTeGhxsY0/kIodYyVHup48ab23u2G7jOb13Xmp/W88dAYAqYch4k7mcqrPjZQJu5lFJUZUz1zbbu+pLouTOh95g6KbbcJNFEPY9cFajYFnHE4D4+HYGp6aD7/O/0DiNtdunFFz1XT3ujth+Z1HO3+2W8IJX+hKCzRz/zkjwXlAyf0na/yaeWXXn1VuZ481gEPucUY4qdkUkHkFhAsN1d1nY/91h8F5fc/+rag/FM//pGg3G5qfGfSGq8f/6NPBOU9C0K/VCrEbOt5akAptdrMG6vcRD6mXNY+dRdNl20DS+dx7UGSpgsEHg5Hne/Mie88gZ6rqb7VQl6rVlL9ddrqZ9VaDcfxPQ6Jnya/e4ygwvm1IVglP/yLoDQkLcUcfmlbc3MLfSA3lXEGKZTP/y5IWWKwmPPpEauNmHpyQqg2D2vAtWv67rK8ojn78GHNU/ybAVZIDzjTOHLADeC0WthTLi7q+821bz4RlG+sKy4tNdSXDh49FJQ31rWOppLIVaVVl2H8G/IvQz6SE3cWR+w6MaG/E5id1fguFfvvtbtPcBzHiSCHGfqCh3py/cH75CGE55D8of/it6LBE/qw70nDZI4xJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTKZbUvaHMSaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUymW1KvyY+JeLTuhGUy7Kgirmx3urDVgTNPyBouErLJHYyboPWyCwxOL+TPo390aI+8czgJS7k5IAlKW7CeHIZrgMVkBPaGvkNsDZAntAMO2T4N+Q+0rcJ7x3y9Rw626R98t6w+r2/LCvDqomya4rjmg7OyVfvoD90XlPfcLhzSk5/8SlD+wkuyudqGRe1sQnWfy+j6ly/Lrj+eUvsf2tu3nLq0omekRWUIQ4PqoNVaL+SEBOQG+g1dybpEKdDRGVbSeUf2qJmo7GujxIMNQeGMimbG1aY3N2Uf1+Fjh/qY6mV1U1ZvL70k7Mrdb5NlYTIHRAKsX52orLpCllWwBnQiwHjRln2nMW8UYQtf17kF9PGFLGzK4UnZRocoA+PQxbOkMb/QEg4ueE4d/fDquix7j+yVxXA2pf7gcf7CdTqwWfXxDHEPFrWwdgthmDCBdXGdOPqqi3Oq3cF9cquOa8LqdSGj+05l+224iHetAP8xBXRKPq82Jj7mxpbaeHNNc0SvqXknCit7zskhK7wQ5obnELFFn9DRHosdrE9EJnWBtXJhu0/LXuIGV1Zk3feNp58Iyn/5xb8Iyi+9LBvp++69IygXcprTWrCK9F3YNgNJ0d4ZOzGMVfZB16U1t9Ti/N3lPO0PLKNrOt0h7Riyzw/1DaKRBmsIUc8Z4rzodLmGsMyzYKlZ45gGpqiDOdGHjXQUFqZx8lMwb3Wd/jldXKPZUKOtAe3mIJaJ+Jrv9uyT1e4ksEr1mmw/OXccPXYgKB84pnW/tCEb9fkZzX3lg3NBeRN2ju32aFuARoCjYTlJm1SOUbYvOk0PsShjvmhadvBtV9a1TkVWtH5d66gb1W+7S7KyjqRk35lcuNNxHMeJJdWO8SxiZzxjq6k5uAXsSr0knFaju63yjOyGXcw1flntHgFHKBbF+I6jX6Mv9+qw4kS9tqqoe9hv5id0TiwGO+chbDWEvU4d6CAsbU4SiAkfvyXFI5XQbz1gK6oN4mH877i/R0wFug1jqxqCidWq6mYuq/rLJDh36LfscwnYO7fawGak2Y9hn405yI9wrR09XbwgZNKZc1eC8tUbsn5Nw4aZlq35gsbC2Jhi9DgYIozRu7AJ72E95uJC61rGhT48X7e2+/tBroUJ7Gna4HOxLaoNWSn7iGlWVjQuV9Y1LqtAhVaAUqoBedcEeolowyKwSlHif0L0QD3/dknxWQcxCS2HcwVZCNeqWn96iAM4B3RgUc44p4NBOmw9puJAGey+C/EGMQ4cWAnHMWfNTMvy/9g+oTIOLGiN9EL7EMRr2POFCL5c5tCHaJmN5cWJjDgyIvR/eQpzxFAmb3jYOTgewhAOu/7rOYdjccBveYz5FLRRpaj/8DuiNThP3ByMVvz/oiKwbb/1ed33oYf1suNH8IPXMQ7C+Cl2LBUn9+r43Kz+w01Np7e8KjW152/8DmIkVFmzOdoxqg/MyKGm1khnW8cvbSjOayPmy45pTkuluNfQGhUHb5CIPy+p8vMNrTleXPbo77sPaBFX903G+7m8nk98jP67i3i53dQ6l4grRq4CIfXZJ08F5XWg1jNAFba4kYXamIOfPC2kyvveLcxovkIfd8wByG30fK1z1TZi5gmd00ZM3ktrnclm9V451PdsSr+NjaleU0T2RNVutR4QS8w/Y7+4ttG38c8Dy+GldE+ul6mU6o8xTBQDJMF9KdbF9yFP/OUtPctR0CnSiAdizL8jdvOR6wgxREdQzHN4np670QUaEXXHPsm8RZt4eOyhiK6sAT/ioEgMHPHOKxvaU1Y2n9L1/Z32bmv/N0VqCBD3x/dpH39xXn32U88p1xTZp3Z/7DZd5570/Tonvyco31jS+S6qKQLUu1MQxnLuHe8PyqWqXnz1yceDci8C1ApQJNvbapP0mPbeTly5iqPH9dA/+IPvCcpf+IKwNEeOaEH+4Ac/GJS/9a1vBeWFBcWOp0+fDsqPPfZYUN5FKf3SL/3SwP9eKCB/DITp098SOq5YVrs1W3rvEtAsdeC0nRCeafC+MAEESAPrSwyotm7nrysC+pvRyqLen+OM89jGmvrG1IyQJiXkpvOYd+fm9a1ve1VtMAyrEcLAEJeHeTI0T+9cZvPmleBYZVrPW0X+Yjuv9WNyXu1SrWr9O3NB4/Jf/z/iQH7kA+8Lyo8+IlTaS2fPBuWJefXfqRnFCd988qtB+ZGH7g3KzzzzTFB++aLwaMVt5a+efPqbQXl2SvPHI29+Q1B+7NF3BOVvv3IuKP/gDwu99OQTTwTlU89ozBWBBe5hA8s9WrOhjUatrr69u4fvIGEUiaDfIFeZA+pxJqNyo6HguYrz+c2pVtG622yqrarYV7ew/19rCrvTbCC/juv7/Eg8guK6GEYjcawMGTdDPuz6+Ea+vLSM0xG7JjVnUsxVhOhFoWfr3zeN2IiYJOaX+OxE4R07diwoP/ucxse5s2eC8sK81tR0WvFeCD9Fei7yQa2W+m+tophz+1VtWjM3NU+5TeW+Xj2j/PFdd+nbT7OpPp/J6PwEcmVEJoXnuMHf0aPRUAJE18f7LswKDbeyg5pqreNvL3qcY3W1SOi7C+7CDb07eNPvDtlA+68DvhSCLYVQqN/dD8YcY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMt6TsD2NMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTLekXhOltAWLf9retHqykcqlZW/mwyKwBfvLGFEh+FucCCwYmzjfDbEW/EFFJ0rrJ3gC7dpt+7DXnj8oe7UbF68NvL+bgpU+ntfHe3dgBNRu6fo92iri/aKwFooOwTbFgKVKwqv5ww/LCjA3J7u+v3ziBd0LTkQnC7rvR99zd1De+6BQSheefzko//E3ZOG2DnvEDio5nlGdnP7qF4Pyi1dkDRhPZoJyKt1/oBbsx0N21SqG6mModQVlWnZ3iWOBBVQkAZQC0Dapruy6Ig7xXbAs7I62He/CtMbZS5dlf9uGHT+gBU4E9UtrwsVFIRUqG7KAS8zIJs6JyZrQpX0/7c1gfxmyVgdiafe2FfSHHBhFB8Zk/TWR1n2KsIBcLsuKjEijAvgHHeKW2PfQ+WjZvVaWbWUb/cqLwaoSyAgPln9t1GUH804iHkVZ9UR0XLup+9Zgh4bpw8nBVpt2+m2OC1j0TaA+75xXHymX++2wukX7Y10jBstbD+3aoz2cA5TSpmzgukBaRZOwT/PZAyF6tqHs+vTm5fgbbQtQWrdFiU5Bf6PtabEoq8pzZ2XZ+oUvfCYof/1JWedyvUx6aqfittpgpa7x14DVewzWhLT73X3mbkd90IclZSdk+zgEmYS1rQUb3W4IL8Z70mqQ8/1gHBk76GDwYPgfw8wpQxZ6RGgQB9nF/MixhfomiiabJNJk8M1IHUrAxryQ6p8UcVTfW2XYgeZmgvJkQe1XWhZGy7+qsdWA7WxhTLHB8dsOBeX5PbJZJWqkXNGYvviKbMk31mUxOjEpq8lMVuv7KMpFzJTF+s8+idAyZK8J0koIBeSlZcfpx4QmisI+PgorezI+2c2jmMs7NaHoKle+7TiO48TQ7rFxWVfT1nV9SVa1XlxrXquq9qqvE6sEz+7NmyrH9U5R4E+9At5v7xuDcveqYgwXlvg+4l4H62Uui7phvI84vd1gm2AuwXGilFIeLM1BG4vjvjFgkJodPUMdz0kA0W6MDbKN42IX1As58us+y3VdpZDRcQ8otUxCdd/D2gZCo+MjtiGaJ4W+2wa2ifFzcSvEkh05nT8nTOf1m8KxVYEL6qCCS2VZaTdhOx/HvEtL2CjKXF+J3vURi3pRzcFEDRGHuVXs9/Nmm1bexDQBuZVAT8JA3yxpP1QsaX6t17TWEhFL2/DVNY2zbFqWwHXEh5Wa6oYYvdkpWUSP53R8fUPxRq1J5BNQXxije+dlkUv39TrarYEy9+dxxLod1BXxuET8sUPvrpExzqWIIeFmHsLkjRcU59594hiOqz5C1LYO2jZkqa75IgY8ohvaN2AsdjC3usOij9EQCChhl+LI4HPCKKUhiKVhaKRhZcx7LubsUPwUx712j/Oe6DqXr+oavwx80icu66Ra72927/CNS+rXX3xcD/pf7cd9SR8m3jjkIz3kOVFnhVmd8863qdJOnUGf/Bt+31FSozHa698w1YGBi5zWPm9/FDbuTcWCjRoQG8BExZFj6GAfl0xlB5azecXxjarWhNKWYs3JlOK/t92tvtTs9Nc03z+1KcQAACAASURBVMf64WiO7HFgAvka62otvHxN+aXnXxW6gTb5EWygQmibBtAi0NVrS0H5hcuKjeen9R5JjLlkVOtJHNc/nNfzbwDDdBZYifUV5Yq7wAIQU0QKZyqtvVsWiKMe45C4jidSyJ2i3VI7+AYvCfwVyoyp/VB+HPufFvLv3HpjjV5qYe+EWPR+PQpa3HHixNMyF0hkQZq/GD2xjogeaLWQw0QdMS5k/NlEzNlFzpEIljpiL079ESy83Y42NqubysE++YL2/uPR/jNcvK7netPxg7o2+lR5UXn9CnLzZ6Nq1LnD+4Py0z3t7Y5t6J3u26NvJg88/I+DcqagOSWZBEZoQu+06eidmlOaa9rHhGCJuEK2VC4pZuYU/2pZ8fD824VnWm1pjH75Yx8Lymzbp59+OigfOqS8CDEaTz2luTifF5KCyJndWJcx70svCX2xvq59/aOPCut06iWhOGp15NyAyi5kFbMznHTRW/gNhLF2AbHuyrZy+l3mVyMMtEZP1Spy4Njj3HfvXUG5g4365SuXg3I6CQyvq34+XtCaWturflIELrZ5XXuuJvIETFNzf5nKaOyMT8zs3B+4kXnds4t922JN51w7r2ffNwb0Ib5jrKwpp/Pbf/zJoMw+uw9Yl0NAgSUyGovJpJ63A2zN8b0aiz6C8FMX9GyLy+pLv/3Hn9azLSvH9KH3qZ9PTOhb0dSsrp/J6hm4XsXwPanZITpYZSKFqdgOvtZ1MfcyidfQmLj9xA/pOHILF4rCTPlA01GMPbbx/aRa1lzZwkTV83WdDjfQXI/90d4vhkV2EY8PycqHEEvEwKve1ze0tk2Mqz/H+A2e1x/yHdgdsO8mwsfziBvF/r6ncRnvKL7OdvRNZbyuPn7za88H5W9c1lqVS+KbQFTvl8YckZ1UrrV9U+vD3o7W5vjNxaDcQX4iC7zesbceD8oJfOeeTOi9kii31nX9Br9tu4zVVD8x4PgiyMFEEcMwZp6a0nvt4qXKJY0J5uGGp0f4vXBwe7vDtsxDsUqDj7t/5awh/2GgRnvlNJlMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZvk/ZH8aYTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymW5JvSZKibbHLVjAdR3Ya4bshWWjyL+46cGjLB6DrWSE+CIiiGAZSitD2D16QFiE7Kt2bLZorpPNyeZockF2QJ0S7DFhkdSD7VIdaJhOB5aJPuyJYI3og3kShf1zDNyjBh8ONkr3AYVy4u33B+U//IMvB+XVqp4hC7bMY/fL+nDqXqGUNq7JXukzf/HtoHyjqudJwSIzAQTRo+/UM2RuXgjK55OyTJo9KPu0V8707VJ7sEgKWX0SyzEMpRT2TgpE+/M2ECDEFaRytDqHVf+WzqcFpu8TGTLaKKU9s7J6zCSBTmgRXzMYQUbESxkYoa1lWd1OHl7FZQgf4NhCP8e9fNis91q0pO/XaRrj9tC4rLxm87Avx/ifzKgP3ijqeaeSwJzA6nATdoh1oJHaHSCH8EqluuqMtn0hBAv6J7FKHSBYPPQxjqEYvGubaJ/ihvACNdjsR2F1loM3bxT2aWzmMdTDHXOweQQO7uUdu0i2/RwsHKORwX5iuZQeIJ9WuQIES68tW0paLbsoO0PQOaEy4F8+lyLagQ58ytFRaE4DMuDMGWHrfvWX/31QXluTVeXktOwv8xnZ4ZLn4aOPra7KGrSNcUZr6jrm3h5sK3eHbhsWkFE2BRAGtF5uYVy2wArq0kmb9ngObRUHc/RCxnehBh7ipxdywcN6MsTCMXRbf4gtJM7vYS2vAuXiwwLbw9yXjLA/01JT18mkVPe7zRBHf09HNFa6LWBrgL+am1H/oBUnLaAfevPDQfm2O08E5UvnLgbl8rLsxw8cke3r6k3N+RtFYXfuefiOoHz4yFFnlJWCc3eUbMnQn3wP7sMxWNPH0sAHwl4+5OOJeSnK6arLfqjjbow8C7R3u2/f2VgBvnBba3q8MKtzPdktFxtYBDAAY7BMThU0x/eiWmM6iJkSCfWreELXj0Z13M/LfrqzrTihVtd7pMfVx+Nohwixq8AkNWAt3O3omWsNIl7QhsSuYF1kqFavA2vnMd7W8XSMMUH/HHfIXNCFjfpGBfsQTB5TednaR2OIIdG3OPd10T84Z6US+C2bFnNWCAPmjfb/j2F9U/NYo821He2CMcexRZwjkWHE7HBtoa09Y3eij1zEZIxXOyE0Zv85V9a0tnKcp9K0myUOF/HnluxvK7D+ziB+4rip1RUvE81JG/QW9pq0BGa8QUwny1wjW7D2jkRUx5WK5p4kLHXHx7U/bmHvnUF8wpgyAWREHe+1DjRfvT74HYPndQe3azql50qiLY/tk4X4wozmaoa0xO3GMFlHooP5QURP8Bm9BPFdjA1eO3Xydy4+Xgif5A85h5zVIeewPAzDxHNIyEIuJHQ+5+Hd50R/aGrb4fwm8EmX5ODsfOQE1nFc+5VV3fPFNbVprRuKQL8nNbCnfPxZ9bEf+QhyU+P4wZB2GEqLxZwYwZr6YVz/M19UxZ67PNh23jQ6urai+Lu6pHzcTBLIjAQwRUD5EX0bjWAtihCrBLQAcqEtYAY2gPxoAdH8sVXkOouav/fM9/f4uZwwFV5Mcz1xgJmM1jkfiL4nTwn7vgZMTBpBO5EVbcYMIURQUHQ2tnSdxx8XFmHvjPJj6ayeM5XRvYikGIOd/6Gs1rzc/nt1r6Z+W2srd9PqKs5pNYlRQF1i/e4CKdDpaF0sdgfnH/fv5GDzxEwRV8S9a497cuJ2gfHBuuViT3uhpnMKEfYh7BWIwYgyR451HDmCUce3hOtOx0NISIynFtoo5jBnoLapo996mPB7OL9GtBW+b7Cduj2V33C79oB3nOjn2K8C7fXEcyrPF9SnKmXd/9kbyJe6yOWtaP/y0pqefWnzbFB+y9s+HJTvPCl0Skih7xhCpWVdjYn15etBudzQcRdjrhtV7oEYk0xceca33qHxvXRO5xPBOgmExeXLwsPwu825c8Kvra4q/3Hw4MGgvLGh+lxc7CMv2N+zwMRcuiR8bAIY7gfvUd6Ee6H1Nc0jDH0SntqE2PFeTHUWzSgYKuEjUgNrRAIokb1zqo9RVALxfbuKtQdIHuY2bmxoHc2mNR+mEFtubSq/6gADPnZoWsexJqxc0r6vhe8CMbTl2IT2GMfuuLN/T8x543tuC8rNqgJTL6rcyjefBa5oXX1pbEx5Fi+uPMtGCetESevN9UXVwctn1Zej+K7aZZyQ1nUKcdR3QvWRH1O/2toQ4mV5Vb/9+jMvBuW7TqhvXzwv5Nvv/+avBeVVoGKywMw8+g7NJfWq3uvzT+gbJ+P/R976bp1f759/dVFxRb2otX5s/KGgXPXVh66t6tm3a2qfXii3h5wA9r312uD1vddjLkCKRAevL0Pj/VHRsDw8XoLfIojHCqXSUK4TCQqcXGRW45I4YybumTNiPMxvtq2db/MrNzQHf/OzfxqUY8DXr114NShfK2tdqT6ha5+M6Xn3p4C809LmJDKad9LI/RFN3dFQdzpV5PJQO2v40F3Cb2cnVTcPubjQ14X3e29bueJWVfV06Vd0ziqO32zi+1Bc60wKGLR9Rw4E5QPH9I2gsEdjPZ1Sfnj/nn3998A3qRZjztA3v8Hfh/xhfc4dPC57/PbDn/KbU+j44D3E6xmKox3Fmkwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplM36fsD2NMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTLekXtMPOO7JNshvyhqn05XtWbMlayoiR2g7HYnqOrGYrN5ondmFZVOL/uFDjG9oa5yGFXStvmMLBnuiCGyf8uOyA9quywaoA3wSLYHaTeCTOrom8RUR2EFFEzrn+LjO2ePJnvG569tBmdbY737sjUH5+fOyTDt9SZZQXXgCvfuQ3uW2Nz8YlOGU6iyfFQLp5XUgb2BX1oI9cBIopXRc775VlN3ajWU9fz2q9tx9Nri8kgri0OgoZJUaOmUIHgOWqz4xHvBOosVhrax3LZbVR4ndCtu1jrbX2Z45+TNP5VXnG6XB9rOs6y6wCxtF1cWFM7IgO3SXMBwx2o0DwcCKp2VVr4PxQsvQnWE3nqCXN6zZcI0Y2ncii/kCP60C2QT6kNMKWQnjGWnhhZutVfROG5uqj3x6MKqJSLSUh3ql4zies4d62oY98dq6xs3KtuzcDk3IBvHQjCx+601iqThe9AzVhs554VrlO84fS6mi/JClGeZEWEvynDTm8Js3NQdtXHkpKC9kZc3mRzUPuz6XFrR5qE0wkF0O6tEeizH4tddgF/ilL38mKP/ub348KN+4rrn88BEh725elS309qYsVokTyBdkIdsB4owIuUxCcwBRPDGM+/bONf20rCfbONd11R+bxJHhnE5oLifuCmutM7ifUqHWfV1tTQtH2uYNtujjn/uyn3cxafi8JhATLs5p9LDGt4FGgoViAhbUMR/rq6+xsNsMjCuimAeTPVmK9jCeXbS9i1hp7z5ZuxIdsHRNtsWxhMbl9lVdf2VRPIIU7NsPnbwvKP/Ij/10UI7D4nckhXpsE28JBEuXeD9gauKwhoymgFIiMgkW5j30+TasQeMJtTUXmjYwnHQM3b1mHGtrp6O5u3JddsBVoIh6SfUHsov8HqyUU3q/7Jj6SWZC1typrGKJWELWnVGyG+aF6CouytKz0pa1bALBXR3IC9pOd5pYm/EuJVCk4Fzr5DOwJEW8nUwAMQGUWQL4JIR5TtIZbOW5O2XAcdohibWBe6411WgzGeBVgHtKx7EXwnt4xCnimvEE4wqd34Y1L21Iux09Q15ddCRVC6GkBuNxEthTtsGHxDYoFEMSG0dFMb65F+xyvidZDXvAKCo+vnM8kdc4GC9ojWQs3MBesAi0ZKNJTJI6AVe2zW2Nm82Sxms6qTHHOJZ7sgzwlnH0K6JCiZ+aGpeFd62m/tlCR28glr6K+MTzeC/gOmKD27ALm3riHaPYBMbxbGyrxM7642EuSyQQW1VVr/tgC38b8L0e2rLd1jsR+8BcQJQDH5tH7hU87GkZwYTRjc5oi6g//t+fhpWHIZaGoJFCvE26YaOuQ9imUBnnc1+/e03895iGpfNPHtW54xO6Xk5bplCDFct6wU8/pfK/fRL74Sb9zr83vXhVzwAqsbN/H04aVn8h/3HWDeNYHT90r575535GF/3F/13Hy9VQgG4aEV1+XgjzFlAhflm407tmlbu6ltUe0UM8lEtqft2sY1/G+Q2IVrcHdAn2KbS49zBPn/qckAP5u/ux8eF33RkcS0Q0L66uCuUynlP8e7MohMLKqvIdRAMypu5iDWOeqjeEQ0AsSmld+dsm4rB2We+01VV9rGENIwrYS2uPE5s4HZQPvPPng/JEXLF0u6ngtefqGWJx7Jtxgxb2bi3ECsyFM+bL7GAO6yuaVDhFsA5iQABtbSmH0ENA1cE5MfSVzRc+G5RXgQDJYS28E+/hMX97UP2V+wZ3xBGDjEv9kH0/8nrERxCfyHwKc44INNuRwflNYiZTyMm1kTvdO6NxMY9875lr/dzMC5d0jbM3FA+NAV00AUTtvoQWxnce1aJ0pqjzb6yJE7F/D8ZoTPcaJube6y39YxLjbHxTc83VivIQOUfHI4jxux3F1TOOxtbbj6g+vro0OJ5k7EpsGtuc+CTmIvftU/088MADQXl+ft5xHMf51Kc+NfDaxJA2W6qzIweAJEXcHcM+JI15h2i8HFBwJQd5uayePZpUfUTqQJsmEb/HR3sskkieLSgXs7Gpdu9hj+i0UUeF/UF57pDaK4V66fi34Xx961hMntEzYI9TWUddY+8RxXfN2E6+YfPmFT3vBc2d7bj60XpyJiiXfORrHLXvTx+5XedENX//6je/FpTLdXy/avN7gmIJF99YZ/ce17OtCbvSSOqczS2tzUUkY3rYFPhAv1drGpdNrGFz2GsuXhbaqYz5Ll9Q4qKyoT58aH4uKKc81U9hUvX2Yz/yX+u35X6/+JU/0LMTpdZ21Sd6MeXKNoExriBu8lBnEWySmuhzrQbnxMH71G4o1YR1F99set3vf5/xt6GIP3hv2wvl2FmGhiBxKmXEI1gMUxnktZmHxzO0id2rqM8UgURKlPvrSQN51i/xmy5yA7cVdPwfH1ZbvGGP7jmG9CfCUqfe1nXqzKH4mmu3a+pXy9uI0yOYv3DNlqYaZ2lTz3DbNOad89o3zCV1nSMKvULbS35vaWNPXMJSfq2icz53TrH6nzxzKihPFPReDx5R3Hv3nfpGnNlzh+M4jrMwpbYsltTenSrGDXFIiHOHjgh/cD8LfSoa8i069C92ZPSt1/Ot3xxjTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUy3pOwPY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMt6Re02vN78EOB7ZEMVjWNzq0L5aFkAeb/i5tmvC3OB1YTDZgTd/1abIjy5wI/CRdFxacsL7qdtvfcY1EQpZZkzOyBtq4Icv6JhAGPizBY11ZZsUiuo4XhX1kyGJZz7sJm94F2Ecd9zZ0/pws7gt3yfrt6//mD4Ny1dcz3DWhun/P+x8JynMnZJ+2+Yrspj77LVklFmn1jvaM4PlPnpAd2UJEP7i+KpukUkvvdXBKVmqdnXZuAQvgDsEn0fKINtYhDAZdkWC57NJ2nrb6cdkabtXkVVWFlZo/2o5mQ7VnTv32AGx3Ly/rPTshuzZY4qF+y7AIPP2yrHwffodsW8eBpAr5VHWBbSKqDFaYKdhD7p4xlda4icNSO4QKggVbFtbxR6blpf38oqw4Kw2NMxSdNuzrMpjd4D7rbKMOLtyQbePxBfXlVkfPFoM1aApWlRXY1LeJf6O1P/rq6et6/ptAfR0eh4XquOpvY1vtubQhu7jVil6m0hlsTZb2+nMGR1wLz5JMa/6KYGx1cL04bXe3ZX26fEU2ygsn7wjKboSDV0Wfg45sNR8IIIc24KONUioV1Wf+6A9/Oyg//pUvBeVySXaPs9PwtWtrnauUVKe06Z+Z15owPoaxfknWd7Qm7MLiugOLuTb4Lf6ObWQPa3rMBT4won7XBCqxM3hKcRg6RB3i3Loo62w31KZDcEuDnY3D+DW8E9cN4s6i+DExKXFY9LejsjMN2+/hJYFUqHdhV97G+sO5IaJ683xamvfrqgk0EzEVnFeJxKhVYSs8L3vRI7fLfvXsK7IvnZuVfW92XOdXMU9dv6Z5/k2PvDco/9RHfjIoT8/KDpbr7igqAtvrGPoA8TydnubXdEExQior+14X7R4BPoUYGPa3NpEp6GMe0Ci04O3AftbfiWM9rJtEoLVd9J2GYqnGtnB23rjaOr8gtEgCaLv0mM5JZTQHeUnNKTHETBFYuzvuvIoTiks7y8J1lcuw8sW8wknDx3rcrqm8WsK4icOeFJbchbSOE0EUjxNlh9u2gMvx9DxNjFdnpz8TY1SXa6uzXNG1M0CmJYFPivu6qY9YOBrChRC5yFibaDfgEPCIrabOyU0QDzba/z+GON6thTmYMRPRRG3Eq0QMlMHESqTVP4ncYazB8RpDw4ZsW3vEeareU9n+NSenZMHtI0bh3LlVhtU2YleGNw1YLxO3yzmigvizQdRYyHKWfRb9Ok7Mj85fA4oxggfi3pR4igjqqYH97gauQ7QFMYBbZQ0Y1kOde+jw4h+IdZLLj+08i9ovgjExPaE98x3HDgblfFZxemgfSSQiY1HY1PeIJMUzst8whnEig1GkPtbskRSxPSFk0us4HmeDIeeCa/o8n+TdIcikECIodD7O2b0XME2gszoHxzDQcM6w5xqfVvnHFVI7V7f04r/6HOaI73HbsVzSD07Lnd/Z/8CAkx1neH2HsFSob56PtfADH1XfO3NOL/8bv8v45+9pouMW1BNFoIvQ1DVH82X2umzT96cV03cwd7nYO04ihrsBJGgjrTivk9Y5oLw67YhQTalJldcvKS95aqOPz8xPHw2OHXuDyvWO1oBWTDFnC+iiyWnFkI2m8MthsqX+0ULQzrUqtJbQEj2iPVxm8kBQjmLP0mpoH+50gbHC/qwHX/vatvbYDnIkB/aqnlo91FlD15nJKm7xXGCt8S5drBuMT3xMPpWL/brf2NZa3Ma5ReQNMhnlx9bXlJeYmFA843mIobD+ei0hNBplIqHUnkkXvwXy232f9og9zNF+Z7TnnTAOETlMjDPGC1wSiMdimdfskNEVal/glpCMLNdU7xlguda3lbf/+Gf7v73svyE41pvT/n75sjAIH4yrb/zo0XuC8vmu+vg3n/lWUJ6f05j42Z8SPvfwYV1/KKAPlZP2NMEkYnqGSl79MHf5QlBOpZXbaAMzQwRny1c/TMWArHb0zGtr+oZDTBJ1+bJQwCFEG+biCxf0bBsbmge3t7dD/+s4jvPUU08F5U3gy86fVz59aelGUCbOtIn9wXhBY6gwrnGcyAIjgvG3tqo29Bqqm6Ul9ZtKUXWTSY42Bru1qvmnjXn9/g8rgKoA87NRVN3t36++msno20gV8xj3AFNAL7Va2L8ADb2B7wst5ComZ5RfmZ7ZuQ6QiGlgoG40dZ9iCQgf9J/3TKjdP7pP69aZZfWTTyQ0/pi357NzT8ZveNWS6iDaUx/IpxEEY4/T43cdtAO/BXAeTABZ9qPveSQon7+s7wJf+MYzQfkNb31HUH7kvruD8uUXhW6cnlOdPPaBjwTlsWnMQzuYvhP3vEvXwNhuYP/ZJvZ4S3UWaQIBiHyKj/wAr9OqIe+DHHk8wbilO7Ds8lvHqO8XibQNHcae2hm8dlJd5AHLZY0n4pSTSc11HlBxaayFNx4X0vL2ys2g3FtVXLWLNbrG50pp/Xj/PrXdT+rzuDOfQ04Ez15EEq6O8U9M0s2SfrGJ3I2PfXIPmK1WEnuyEvJKReQHkfPM9TQHrGygXyE1u1dpESfLvCj2jghdnSnsHY+O6/z7lB52PivSnPPx67rvn31Ldf/qeSG3//v7vu44juPcgxxzsaF5+GJbc2IPqE1ncLcJdTo//I/BJ7mDD1Pu0A9K3z2POtqZVpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaT6fuU/WGMyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk+mW1GujlOBR2+3BerILu2qYEfVcnqPfNmE33qGNLm1CYadMC6poFPgBWKjTXpOW3Lt2T7TGj8Z1jUxeNk4xWK11YJkVc2mlT5vuOI4PRtXQwnaD2IyMrHzmcrLHO/GO+4PypWXZ8i2uyYYqA8uvD9wpy7GjJ47pGWCr9s2vvRCUT6/JmqlFF0FgqbIZWR29400ng3LBlyXi9abqocv2wd9WJXcwApUqrdCBzqnAborOYsQkhRAstBWGjTUwWj5QSo2m3rVW/fuPT6JmZyeC8tEDsq86dUH2YytgZXVhzUqnqRjqmn8V14WVvTu0wsgl0ZiK5TSmphfkX73rypdLEUEG+3fYPpaApvCS6l9HpoF1wph7ZVl9rEr0GTy25tI6fwFcpYubwEkt6xk8zC9pPHPUZb/Vc3Zgm+cDP9NGzcZiuk4Pz9+CpTstdVfX9V6rqB8f89kY5o88mqQDu75Gq/9sEdTHwoSsh2cnVa8t2A5GQ2MR4w9jfnNVSI9eVVaX0TyWE1KViNehXzlQSuHyaA/Y//Nf/2JQfu4ZWUYeOSar6ZO3aZ5+9ZRspNdWZNPK8RTDxJdH+y5ek33dJuz9fPQlInyIs+hg7dwdI0SedOC330S7dF1YJhP5A0V9smrg0010nsN1eTA+yR/a1pydeE3Y7HMuQ5kkACIpkkRSOJoDmnGhGWjjF1qLEJ9UMe4jOD+XVbvlMhj3O3NGEzgmz9P1CrAj3MDYmpnR8ZN3yxY5ngAGCqiHqxdk5Rv1ZAm+sP9gUD54+1uD8nt/8IeD8tyCLF3D+I2hRsojoR76e6ONmAz9J57V+pSZkt2jl1XZhZVqCxag9SrmRmCSYih3YTnbbjZwDrCCGIu7trcu8aToj8mUzm1jaO1iQh3HcVrbQmJFgV4jPimRgm1sCJ2JtQ3W6i7QYS4wUGN7FRN2VjXf9Wqyrm5XsZ61VUbY5oAe6CQiHPfqbwhDnC6Wfu4hGi2NHTSVkwb6s9bUNWPc5ewc7oC5UUcXL3f03nMpWgwD60TbVLxGKq17lmvEKaqc9zDnY6LahrVqIqPz01mVbw52Ch8ZcU6rAm/L+LOOBvawtpSxZ9iA7fTYpNAQCeB5O4jDGsAZtFFOJ7F3Q10nUxqXhbG+5WulonHLZylV1Wm3S7L9JQKpWtNvN4EX62AOyme0NqRTuk69pdopYc9C1FEKc81mURb0ExOyq93cUp01sQ9KYg7KALNGS/kkuC5N7CPr4JS5of1uUHTaHVhyEx2Ac1K0dMfxWq36HQezwK4eO6YYat8eYTki2IczxgihjoiRZAfEekb0EnEXIXwe3xvnuKMdojoOrJe/d5TSYBwS8bmhzBHxSaHjg/FJob3BIAxS6P64hjf4en4IG0UsJuZsdMH3vUnn/NFplbda7CjfXXWs+1/8mn77ng/qBb0cOgr3VnhHfwj2yufiiePpaR3/uX+pa15f1IU++0XkP/zv7b1Mf7268jqqn9i6bll5QOYz0ujPc0BspkvaM/wlBhTXnyhwOnN7tHYuXlX+KAfkR7HdP/7l3/zd4FjFeUzXnkIexNVav+ppfYr09B7JOPMKjPcG45N4Dvd5SeSdWg3dq14TLiGF3A1z2BHY+ceAL/PbyGcgDcGc2DjiNqJ6e0CdrDS0Tk9jrsqhTmIJTUQxrD9x5JlXM/0cQTunALiKdXka+0Kup4ePACcVY66auXWs+8CepxHj78XWPnVFQad3v2Ix5oP8LLTYpAAAIABJREFUFfygOdpzzeS8MFiep/rvAOPVAB6S+6YuEEhEJoWwEqH0ltoss62NSiSmftLuqt9O71NfGps4GJRPXO7HlH5Fx5yEeAqtlO4z1lJ7+QWdcxgL4NsfEpJpI6IYr1IX9qjN3CY4bGGCBvYyHvbDUeFPChgHsf3KYa/HtGedRb0ec5aDcrwwF5Rfrqnv1RPKMe8D4oyIqmGoDyqOjWEU+R32hWSy3yYHDwiRwxRmPq8YfHJSz8XwMBrXvxbAwTh5txDFsTFgYNLqK7228oX7CqqzDNp/Zo/yGMUl1cH8LFiSI6hIGzFKRPPVq2dfCcqNhvpnuaK6uHju2aA8NaZ62VoT6jmaVJ6s6qhOm218O6ggKdFTHzh6u5A/R0/eG5ST6X57Ty0cDI55eT179TpwsogP35DTnP3jQJylkeA5gb3UG7E3/qSr/FU+p3dKAKOyviGkWLOmd+2mtOZFQt9SkfdBfj6CGCOV0phuYC189tTLQfmuBeTTsM7c9cBDQfnn//n/HJSjyPM/f0b80aMn7gzKb31EqKQo9o7F9f4edxfB6ziOM45vl8srypW/8G3VQXlFcUg2olwvwhanTiRwEchk7MmdDjdM/Daioz18i+p2dE5nxElK7hDGDafR13NOFOC9bkf1OJVTPzwQU7wVXQMevqrvzQ+Pqz0ur+ia68gtLu40xyP79AD/SGGMc7uWGwfhW+jb2/mSfnv6po5fXVPZwwvO5NUHxrPIA+KcIvi/8bjyQXUgk6JI4R9Bnup4Vu+KbYBzCqijK5oOnIcP6BlmskCu6RTSR50Y+i3ofc4/PKmTzgId9Xktx84iqKTV7f689aYJoZamEzr5c2u6+Cs9zc+NrGIDJ6Z64nrJUdYbykxyh5QHK4QBex3nm2OMyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk+mWlP1hjMlkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPpltRropQysKCvVmR202rJHsiFfVYPllxtf7BVOi0IiTKixY8P68yEJwumKOzdabsZg91ue8e+yoelE/3cI8ClRGA3GfFhY+1+p+39X1WPts2wlezx/TxahctO813jsgI7/pAsxD7+B5/TdWDDdmdBdfC2N8vWLTUvW6Lyi88F5VeuyXIukYBPL2wNad169OieoHzPAdkpXvn8V4PyJizFPE/t0IbFfa3et1eKJXWf+aOyOlu8Itu4ysZg28NIjL5PRNIAcxOBpTr6XLEi665WA+1PO7AhZb/33e2V/i41NiUrvhPH1F6HXgZqpSKsTQd+j21Yh9Eycn5WbZ3OyZrRicFjC/XrxNSHHVzHwfWJ/NkdO3HYkWYTQF8k1QdWSrJO26zKXrRc0/EpIGbed4f6fshOHc9SUDdxerDKW8K9blT0fofRZzKwN2PfoLV+A7Z5kajKddi9JfXIzr5x/ePShvpqFSijLYyzZFLjvlAgUgoYCKADltZlHzie6f82hWtMwjuNFvj1ht5palweb3smVW40VGfnXhWy5Y0bssLL5TSvhXBIRKKRPcG+NeT8UdQL3346KM/BmnfPvMZoFGvSASCWSs8+H5SJ3eMacu2i6pd4mEOHjgflG9eEyomw7mgXTevHXr/9OD7bPrBLrPIove6xFsIGM9bSGO0CW+C6XAt1mVCLhtp3cFuH7d+BNsCkTfvpFufvkJ0+13tY58K/PtXTu9TjssYNcVKIZ0Kd1GAH28O9koydiv31OB1jH8f8CTtuIiUzWY15jxbisNWeWxBi4vkrl3XNhM7/Rz/7k0H58PG7gnIM1qpsk14IezXacrHOdYCs6Xmau8YmNC5dF0wFWCbHUjrfzWstbMKivV3XPNlpASeJuvZ9lBHDxWHb3d1B3sUQi/YiXE9VTuDarqux3WoAVVNXvBf3YM+M2DmGmImWusSJ0NDSxfyVgA1wcgZzGTCObTKQfK6XOtyElWg+hf0ErdsTqDM8GmO1VVh6xoDs6SDUrbeBLYPl8C6Ss4W+stTU+MtE8MC4ZzJJj3TYg8N6uAPEbAWhUha2qTHMQR2MuQj2KNmCrlOqqy/UaPs8isLa0kR80YItO7EIRBIsAzGYQ4U16qpIWt9zf0RUAB2LuYREcA5RSru2+cvr6lQtYJqqNfXrFWAuafE6Pa7rbaGNtsqK8UpV4CO47hP1RxRVXW9SBuKC+9HL12WbPzuhtaKJ+m51VH+HgWCNY3zXm3qeTFp1f2Np8Ltw79hq6ZxYDHt1YtkYHyC0aO+snX5XdZxADDkG/BRjnFYDiFHMobTS93qwHEdbdUMrmu5LpFwE/SyET+I+g/mFURSndf7fn4jtGYZVig0pE5kUuibmV5zDECd8HWfwOTtlF9fziU8idmkIjimEYQr93750nYMiUDt7ckApbXz/0c5XX1TfOP+yXuqOefqMo264thGZxOcflpLAmjN5UOWf+XlVxDPP6QbLa1hgTX/roq05uyrSE04G8/oE2n0SbZ3G3MVhcwD7sgvYm1xibAJkw+KVU0E5ArTAPPIrtR08faUoe/tnnv5WUF44qthvG/nACMr5rtbF+THEW1vojz3E4CF0rf6RQRybB/7n6qqerd29EJRvPwBcAocfYg+fGKMo8taYM7Zuyia+uk9Yl/3jarkJoC6rWBLOFbGf6Olex4GeiCMOj2JhbKVu9O8PdGQae3Ja43Of3G0Dm8G4Hmun21ZfmZoSauWBj/53QfnRdb33nb//n/SM59BuBVz/iPKIbpw9c/R077uFEk6m1N9ffEFjIok13/OAm0bcQX7GzKyQj+NTyktevnBOx+uKn8bHFONsIn9+dk24nsaq9vWJiX6bvXmv+mAujXxgW31tpnB/UD7+jkeCciajc+7BHEH8ugu2yLXFq0H5a1//RFDeRY86juOcOKh81EZducevXhcKZx3osN70W4LyU1/Vt4XMpPr57G06v1J/ISj/+X8+HZQnkkAW8TvMkDLF/Pfb36TnOTatdnvqVeGCt3e+e3nAhS9VtA/Ye0D4spMPvl3le28PyvsPHQ7KCcT4/LbFeDyEgUI+jbmOJPJ8EUwIHYxv5nhHUd64EBvjY+rb2GaFELcu3nlqRnnXH/6hjwTlKrCCq9sac5/61Md0/IZyp2WgaZvYs8cw7teWr+h5iv28Xqum/eLesSNBOYVxeaKmC/7EAeXdxhnTAo+dBnrtH2Q1Rh/HN4r0lOaa9//wPwjK33xGOelnnvpyUOa3zCgQtBHsZfjdluPm5JFDQXlpRaima0WuZxq7ReTT7n3DG4PyxITWvChikvvf+khQfu55zZV+V8+2vaX2XLre58kU0R71TeFb6tvaD1+7dF73RHzkAnHfwbpYw9xeLFZxXOO+S4Ya6q+D52VOv4vjPZRHUSG8zDC7jGEkG/wjmQDaB7m8t82ob3RX9H1jT0Jt887j+u3FJV3zG+u6zhk8wwcX+nPp/3qfjuU81DOSQWeRM/z0Zb3gi1sqZyIaBw9M6PjtU0CSYg9HNHwTlZPoYgLDdwki1TOovwnkEuolXQdhlVOp6rfPrOicUzj//ftVPjyrG+zDp10fbQVikoOUh/MGEPi+iHvVibzf+cYZx7fO/cizviml2PyVVzUPRwvK83lzWjvrnl42hFUitjS0pA9DLDH+HPz95vV81TDHGJPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCbTLSn7wxiTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwm0y2p10QppdOyGuzClq0KK7kOrKNaMVh+xWivBAt4WL31wFqg1bUHbE4iKauuKK5Zr8h2jM+2a3FI9E4M1rxeBxaaKV27FpftmRtylRrsZ0uLZVpL+7Dn6uFdb8Kj8wwslQ44sibsAfGykNazfeQBWQ7Nvf1tQbkzJvu/U5c+GZRXgdCIwd6Itk4R+A+/422yXzx5QJieU3COrOC3+Zye7e775Et8bqVvwbkJa/+p+2UbmTmpNtm4CYv0lNpk7qjsvvMLsMOG5XESFoRbZ7eC8md/SxaIjiv7phis60BnCtmY9zrf3V7p71KJsYmgfPSYrBnvv0u2p1dX9c5rRfWlFt6tDT+qLCzr47CXdyLw8HLQCeLADKD/+7ADrABntWs9x/GUTKrfeVVdO58E4gV9rQwr+yIxQwn1pfGM+mMKYz2B9m3V9Vv2Af5poIcH7cKWvdFUnRUrOk5bdmIfiLHqwpZ/CtbwB8fVh8vAYhSSmENh/RvBvYhHqgHRlkupTvKp/jmcP3mNm6uyPu1h/pwsqB9gWnO2KnoPd1U2yqUtjb/sfth+wpY1hEkKoemGlCM0nB490d5tCgiDjRVhzZJ5jdfJSY2ng0c1djfXNU8u3ZAlZBa2t72extPixbNBuQ2Ui++pXyWI62ED7lhkNhz1nSbGmR8hMgDoKzrZt9VnYrCk9YneGeJeNxyeNOyswUdjsJzuwZYz6g7uP7QPdWF/HIlrXHRbWCs6GBdxeRD6GMdEQ3Tg6V9ETEI82i6yqlaRvWASluCVsp7r9vuESnR6QM3duBKUs0D9XLmo49GcPBDf8dg/DMqHjsnGNQr77h7mqR4aLsI69kfbjjc0gaOt8xOqo1hC1uoxjJUeMFh1zGMurkPERieq81sN+O42gXnMa+x2HJ3T6yGmzfXnjC4wJA5wIhwRIUwo2qIH29pORc/ea2CM5mFxjvHKceBjnQthEENoEY2V7Lzivdq65rte64qeswlrUFy/kNbxLtZmUhlTwHBGsP5tl7E214EXwPm0CaWjZoMsgx18601Yk9IiPZfgOADqiKQrUlrRPsUKPe5VzGawJ8A7NRp6hsKY+hxdwEvbsGh1RztG7YT2RLQ1H3x+BYigmyuKKaantXZulzRnethHEicQh+11C32ASDhaqHPeq+1g6Zqhfamu7QENEAfKt1TV+OP+dmFGc8021oOtEuYCYutQN7U6YnY8j1/WSWNjQvStrgmdWsgpDiEOiXvjBPxy4wB5VGu6TrkKjACC2pkJ7eM2tuRLHAUOuYM1cmJSNumJJFBTW4p52jtzWAq433RK5dVN2XcXcnqnCNoy2sTePq7fxjCHtzB444wNgLAhjisUlXLgY90f9Rg1xGwZhlLicb4mKRzDsEpD0Ev+6zjHGVKl/k5+x/dwboyYIfwO+7yhmKZQEwFDMKbfFtJ4yI3v3+58HWP0zz6n6xx5WOckc/jBEORUaHvE+hsy9xPDdPdbNGf8yEd00V//NYzREbd0vxV1B9oRXS9kp+6hf0Zexz6Ia1sKM9ZDPjDRvub4NmI7F4OEeNxLQElHk/3YcTqqvVEa2ORES9gCElnz+zToQMF2ZoEFWu0iZkOcMBYfPDGkMK97SN7U6orbNsp6iMsbqPCOnj+FPGAaiFKiRZsJraOdS9eCcgu8z3e+Sd79e8a0n2C+5gga98UbWvuTPdXhyYPKtZL+e6XWf54LLa2bJzO0iMf+HEedJFG9tPDX4TVgOVxHa2rxAvJvm1jHgZjtdbDvnQXKB3seIoZGUVXgSogS9mOI/4CFXVpeCcqcm9tA6/gx9YHxWSFhWsiLrm0oluk5zPGpjTv4RnBlVXu61g5Cd3pedV4EmimJ8dfzFB8+d01jdP+svhXMI77uYTNTKemahZzit0fe/GhQbqzpmkng4Gdvvyco58eFgfrME58KymXsC1e2lO/KuOhjmI/GJ7GAR3SvjS2N+4sXLwVlxp/D5OHbQe1u5VquAwXVbmm8rm33ywXEIeUmnqUIBCu+qezZKyxWAfF4AvvFOOY75q+awN71kAPqYg4iqpT5mi5yevw2N4qqESmLfV4UsXXHVV20kVM7dEj4one++aGgXEI+/PGnhP4jqq4LfJnb07rEbwpryLd5+AZSONRHVSczyi8d2nswKI95CvIeq6qfzJc1p/gbGkM9tHW3qj54Et9J7s7pmusTml8+9OEPBeWpw8orP/8tYcqqFe2rWw19a3TBmeE8SBztOpBCMU/z1ANv/kBQPnREmKQs2CxTC7oX99Zcvw8dURveAMa0ui7UVZpo62o/39Ssai5tYqwSMV9vqO47TdVxrUbcM7+R6RlbmP+JI2uHchrE6g7LbiOmG/HcTWjfEf4vKA97ByA7l5UTPN5TPc5izN02q/Pvm1f5xoru9Rcvq94vYhr7gf1qv5+9u/+/GU/XwOc5588v6Xr/+bKOpzCX/8BelW/DN+Y0KiSbRaydQvyEoK0MTHwJ+Z0lfOtP4Fv8bQifDuLbiwNEeAL4zAcP6hQyRz+xqHv9X6KHOT+B1PIHjqo8lsI3S7wjW/Z9h/SvrYbO+eXzOv6JHdLig1rqnSnkOQ+P63f7s6qzx5c1x93r6YHzs8K2rbj6G4Bh34o4nPxQ3/UHFt1h3xqHyBxjTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUy3pOwPY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMt6ReE6UUgcVPJiNrr15b1l6bsECjZ3YIkwTrHw+217SgardhoQ7XSM+D7SdsYyNAGHSc77T7TwOTFIFtbbMpC7p4SuVeAlajtKOj1zXss1xaVXZpRy97rngB9t1j8k66CefJT3/mM3rmvCwZp8Zl1XbsbW8Myt7effrx6o2geOGG7NniOf12Ai5NTdjvzy/Iku3d73wwKK88+8WgfBr2Zn5EddVu6/g6EATHf6Bv59bLHQ+OJbNq72xO7xcPWZTTDlvHt1fVt26elaXlK6cuBOUrZ1QHVaB5XPS5uKe2jcP+ijauA7rQSCkCO72pfbJgfdNDdwbli9dkm/f0i6ovWsAR8dFswT6U1nD0t3ZlzelEiVtSX/KBKSJKadeyPhKyIFVFF2Hd24CtYg7tFYE1a72l99iENWGtTltA3Yu2lQVck7Zx4xj3HN914JNYf7W2nhnucE4C/ScOy/omzo9G9ZzTaY2LFZzD+YbIni78/YmJm55Uv0gCN7GxY91/ZQOoJXiuVoECmB3TXNmBter6NixDK/JmS6Z1neVL8qibOyrPtmgW9UrCRAxom4jmAy5FflQT5Hc3Pfvb1/ycbGmXrl4JyifukTVrt616v3H1elA+cFj2kZOTwhNsrWvssoN6SdVFqSzkQdQD5gcWrlHgVmLwm+vu2PG2YPlHlJzrYG3DgPXamt8dF/ghYl3QSDxOtAn/AjdkfUfOBgdm6DCwK3g2GsUSi+DGiEsAfgPxDHFqPdiEei1hIrsdrT+tqMaZDwQPnaPLsEU9d0mIu9mx/jPUmxpzHuaIKfSDw0dkKbiJPlFclUXl4jVZjZ64V179j77/x4Pywl5Zq8ajZBCgCKvGHholAjyG74/230538NypHOyFY4q3uvASj/bUBjHEiDHMRUQDdmHXTqwRkRFtWLWW1lSOp/U8iRQQTjvPkJ2SDa0L7kMbaJ9mXfNItaj5uAHsChe9LqxzY3vvCMoR9ve2rt918LwJ9cMQzgn2wNEkrHPnNN+3gFsqbsguM9uV7a3Le8U1ryWxtyAup9XV8S7mCVSbk0grPiE2rQceSI912+3XVfSaxud4TXiXSETzVxyLerOjOotj0Fexb6Gd/0QOc42qxmkSc4phmYAN/voWxiXxBqM9FEPITneINy/nb879ZcTum1uad8slWSnns2xrVUY0FFMgdiS2CnNvJKE4bBctkgGesowxX66oPJbXOkHEWhhTpvuPAzFQb+j+jIG5Rjaa3/lc/WsiTkcsSqTmxrbqbBYYub0LGiyzk7C3rmOfVcEc0+B9g2LIgj6PvUgbWIxKTXVVr2kdHdYm7V3L6jj25y1dY6ukerq6KOt9ogwnx4UFSGA+b6GeEoipXeI62G5IOoRiGOztI6HzXzN18ncvYoRI4RiCHQohiL7H811YU4dRSozJBq+dofDC+yv/6zjh9whhnYhYCrGvdU/+FqdHse1IhEIjWkt/b9bnxMj93ufVf+b26KE/+k91fmoP6gb15LucQ3GDYXbRUCKn+/70L+gHFy/qJb/yFSDIu9/bO5q+P2XQeHHmSHFOc0ibhroAY/dQX5UOA0VyBAPgLAaPi0HC6xNtcWZnEG4hlxjpaQ5mjija1O/KN9UHsTw5+aSeawFI6WIduVasix7m2hjWjxbWRR+YkQjwGz1fcWwM+JatZeVIO0nFEoVx5ULnx3XfV77yJ0H5yZ7W/pdeUj72nQ8JU3twj/AzY3mttUk82+effikoE41y57EDQflGrX/+jYbih/umgEFEoxGDHUUM7qN3tbBXuAq8zs2WGugN08orTzQVv/vAWHXfrHpyStgDY//h3631eBRFTGapqL1JJqv2XS1rnzU2ITxxLq367QHRFU0pHqqUFYclgKefXtgblPM59Y3SksbU2ctCZW+hzdwdPJLvo84j2uf1iG3ep/6YygAJ4is3tYlcXhw5jk5JOeNCV+ckZoQFihVUH2ef+ERQngOKJHNQOYw7TzwSlE+ffi4oz09rrNxxrzBMF29ofGQLwhTFkL9tRkLZJOd7USajcX/0rpNB+ey3vxmUH35Q43v96992HMdxxvEdY3MVcwri+ktnrgbl4n36LrFn7HY9APAtzYZi5LUN7UfXNxjrIr/haT7YN6/+lMBxl0HPiK/vcRdY95r66nYXWGvE67mC5pZ2TXuWc6deCMrL26rTjeUrQfnEceHvmg3NpcV17S+Jgfewv9x/4LagfP+b3tN/Fl/7lLfcrlxbPa1cwnRP61wdaLKNF88E5Zf+4smgnF7T+LvY0HOd8zWPTCE+TDlAaxF9jT1otarxvb2p6yeTejaOic1tjbnNouoyHsf+uKo89Myd7w/KHn6bSwBrVNbxHr7/jo1pLpndy2hIuMHJCeHAjx/pz0Orm7reyrqeBZ8lQ99LqsjPbVeQ2yMTm3hC5HeIPfZxTeKYyXVxeZ0QQ3q0xyKDS6ZomKz3B6d0nDbW0ZtnhMe5b0z1dTfwSfcCv1PEN6s/Pa1znm2o/NZ59ed/rmXMmU31r3+1pGv85hmVl4G3/dABHb9/BngjpFFB13QKwP+k0viOgkoodYBbSuqcZTzPlrqnA7qQ8+A04mR0/Rj6TBvfIJtdzYMP7UefRAT/a9d0od+5onP2ABH1iJZyJ4m/iygCmZTE3rqApTaDdffSztRweVv3nNJWwcGnfue9B3W9s1s6/8VrmsMfigmJuDCrOeJmV7E85UcG10EYmTQsTvjuY3HEU60mk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJtP3J/vDGJPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCbTLanX9ANeWpalWyohbxyikfI52bi1e7T6k1UQrXajsPmirWECNugRWNbHPZVbLVliEdXkg4Oze3liAhot2R7SYotOVxGwFWhXTcseuvQkgCVJ5uUhlJmW7Vl6GnZlsGosXZVV2NIlWQiN52UbFk/AHigPjENS1kKbFz4flE8tA2EDT7g4LKITGT3DO9/9rqB8eM9kUP4vnxQa5fwWsDsdXTORgW3+lu6b3cGzTOxRfSRhPxmlFTOlbuMsXREm6Uv/8dmgfOll2F7C7jSf1b1oO0j7bpf2yvSjRdsmYkN8wkZEfkJ2d7FxvdDhE7L5e+dbZON37aY8vJbWZFnVgPXjlUWd34AFaLIrCz0/JttPB7gJdwhiLERG2RkwmSTGNgbRvmnhLhaBzWqgryVhERh1gWcjnolW6TocwhI1aUEPe8aZBCzUYUuLLulUgQhowX2P1nJ0rWRXoqV7pE3rPmkPUEa0+SLSJApL2wzm3FZDc+L6puowFu3XG2geIets2gUSudNs6M2rDY3/KO1L8eKLl68F5duLsjhMpcCLwwB0o0BzufBbg61miPsxgpqal+1wu6X6Wlu8EpTLVbXLvsNCjhSBnitta4wePin83I1LsmQtwc4yinXRw7zaAdqHU2wqrfHVqfXbsgtLPhdYGfIL3ZZsel3aRGIC77aJj3BQxrqMeYHjlfaURGvQhjKV1bM3moPxDr0exgfmco4/PjPHkIuYgVbdHfrsN1X3SQ/W1A76dlvntGF1vLwK1Fy3f/4csGcLB+QnOU2kFmxCswUdv3pBFpWrsH/9ibe8Lyjv3ad+FsIh0ToQxV4IfUlrQs7no20BGoctu4vYyPGARuI8jfjPha1xDKgQL6329eEHz5iig3W0DgvZ8obKzQqsrGHnms71+3Z9QzFNekzrbAwxbxRrVaglIoyLYVu7KUvmbkv9JJJWbEkUmBPqJwjIcX1iqWIJoVloZZ+cEt7RSSCOhb17NKa6zM6q/7OLxVO6F/cHBfA9/I6e30vq+pzPEnnZ9OYPParrF/q2x7dtCE1W3xSaLArEU6cm6+HlF7+g869+Q8dvqI65J0kk0VfAmsNy7YxPAisDjEEZVqzxqI53BocPIyOiZjwwSojPySaJtdK7VeqqmJU1rZGb8KLNZ9U2YwX1kyRwWo04+SlYH4jBCUWJ/c5HTNU49mob2N90wM7MpmCtDvvuWpMoCeK8dP007KQT6L+MvXZRmI7jOB3EbbR/np/SnEGUC5Gyk2PaH01NaH7c2MT6F+N+ijEZMEl1ItdUPxk1QwgV2GjqGTzYdneA803sHE+gT8SBxcogBqgAKXf5hsYrLb6J4fXiwMK5g+fQUC9g/IN4tQPsXAQYNOfvEUrJJbpoGBopMuT4EKySO+Q6xHCG7jUUiTTgnMSAY3/13EEIptd4XjZ2BFsQEA7/2szOizWNrf/74zpe6+iB/pt/oRfI7/3O/FX/H7zq63g6nL/niNbmf/VLqsT8/6bK+tyndE6tNuKLy99jPQtU6ySOjyN+ihPZhjiM6CXi29nN4yH8lsr70WcuEOcUHVyOAnXZ6vbX3XJTa9KFbT3jS5vqy3MF3WcvMQR1dea1ltaqE3fJD39rSXP55rowPz4GeA35oDbwQ34IJ6Xzy8A3Z7F5AAAgAElEQVRHeMgx1MaEeMkgh5nG/quCOltBmFxu6pqXL10Jyg3Uz+FZrVdp5CWXqkBPX1W+9/pLzwTl/+N/+WdB+Wim/y6H8nrGfEbjNo74t1tSrOQBcRjLqc91thSf3LWheOYpYBAZhEeBknUKQFy/CzH7TaASrwi95P6hcoqOKL8jo3iceSzFk4WC6mJiTMiWJPdN2I8k8b2ihjxZA22TA07LA7NhDPjHFuK8EmKsOvJHqR08Ti6ivcYUqPanF9WmVxvKn7e3sBe9qpxOFN8Tmj39NoP18p6k1oPNa0KBx5N6p+ljwoLH54WKWTsvJFQ2o/PvPKQc157Mh4PygWnVx4KvcfbCmma5pq+9mBPlwvi95e0ZI14FuiqFmLzT0b0yqf75hw4uBMdKMbVNB8FEErE8v7tsAINdLOvbz/lzp3XNDc19LeBj9wLPNjWjvfeVqsb9noWDQZm487a6peM4+5xR09TswaAcBW6OSOTlReVCJ/Oqi61l5Tk+//u/EpTbSY3XHjCAnbrGZQuY+3Jd3zhbVZ2TQS7JBQu5s4MMK28p791dU0Uncrp/PYU9WUnnP99T//p322rrJBCA6wiC13vqb+6m+sn2iq7jIgcUphjzm5iuWRibCco11M0mctI+Nq0e8mkXzgiJ1mn9aFBuNdUny3jO2Lauk0xrPuhGNA8V17RuNOsaLxMZsV/iO88wM67frRQ0Ea6tAdmLOMgHGreHta1HlJLL7y7OECF3GMqp+oOKDmP2UG5tBBUZ2mdw2B98zvqa2joR01h41zGdfc9enV9t6KL/8QWd/8k14JbA8Pm5u4CnTqh8arlfp1+6ovucwOfKjx7TPdN4EW4LCxNAp+PvFNha9bZ+W2mhj8X026Vt3evFayqvruucH7wXWDz2JfCE2Qwecn/EZ8az+seDWpacMrDuHxfJz/mzRb3X/aBhYug4KeCsiYcHndrpYGCczPafbZKfQoCWQnrMmcvq2o/uUX18+qquN4E4ZG9ae4L/UldMXezoooz9hw5Xd8ieeRgTDBrtL5Amk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJtP3KfvDGJPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCbTLanX9AOOwXqrVJb9mAMLUC8J+2LghWjBH/eIT4J1uy9bK9rUx2Bf33N1ThVWgw4sOzuwxE/EEzu/0/0bsLGnFXUbNpgu7PmSBd0/Mwnb6HHZicXjqhtimCKwtJ5q675jm6q/C11dpzuh8lZV9pTpWXkUfeEZWbefr8j6rfTsC0G55ut5khlZDrVgm18AguWtb3sgKPfWZSl4qah3oWX21JiuOX9Ytnxjh2Udl9nTv74bh0Uv7MFT/y97bxojWXae6d0bN27sEZmRe1ZmVmXtVV29r2yxyaZIacRFFDWiRGssS7ZszIzGgCAMMPYPY2B4BjYMw4YBA4Yh/xjJkmBb8misIUcabjJXkexu9t5dXfuaVZV7Zux7xPWPyLrvc6XMVrM9Mwq2v/dPn468cZezfOc750a9D2z1k4DVnL/yYljeaeleyuhnCw/p3s+e0fVzPdkwfvvbF8Nys6LvDtAmXeKz+Lswb7SREa4Hz3L4W6Vn1W8fe+KhsPzG+ZthuVQWHqsPe7xL19WX7tyU99bYYVnOukSLwNc6cGUxzjG1DZxPd882nbiUXEbnSPs6dwpj6Oa6zrFRhY0g7iSOcxKlxKPGMopNKdjFx3zaE6tvlBrqM8UU8AfwVTvIcLqH68ZhUdsiSgkcpvE0bMRyijdNWPEH8ETMAp2TSGlcjo3JLtIHRqDdGrYPcTZ31mV12EI4p50yEUD1tuojDbv7PHzSSjuyXqxtyyY0PaVx6SThb8d+7MKHDXIHrX0/HxU985zQHBeBu3n1hb8IyxFMH+LY2qrGWQ397eQDZ8NyaVu2khvrssOdmFY9Nms6JgCqIzapeg/Q51t7DI+IuxzsBVOuOkSA2BygvWLoj8Q6BYP4vsdE/Rn3twSn5WUO58wAxdGGTegg4AjkHAzbT2Q1A29/27xUQnXjA+nRpkUf8C1+DKjCuI7fBV6jCxvlNmJiZQ8x+OgjR8LPlo4KPXP7muy15xET6zW1CePC0klZkS8uLuuh6IztoEx8ENFVaP9YpJ4Q8EYcpZTMgYtA+1vE3QEYNC5xWrA7Ju7FQxu4qItuQ/MSc6M4cjViT6qbiofEArXcoX3uoK32bdeU+/nIf4k5IUqHaJg4nqmxCzxiSfN7PCn7WS9J/CRyIGJGe/BhBmcmltB53LjKg67qhn2m09Fg9DEvxoAd8pLELbG/6bpdoFRqW6rXWF7tH+Ccg7YsivOLwNHt1dX4ISEoxxfOheVeR/G2U1eemZiUB+mtl9TPGje+pPOkgebyESMqyEOQkzAX29mBDSnWPKyPGKxPR1HjaAtiGwNPfSABzl0PtsY9oKS2kVPcui1b5QzGRRo5SBros3pq/5zCwz2wz9/HzmKYRayU56fVx1dW0TcwJ7WxqGjiOerArfVpw58kHwZ5o0/EksZfFxbfjNIRJAYQRMwDJ4rqq5EYB7vyXE7P2GWui3m6g7G7W9ZYd4EUGi9qLVgFmrW0o5hEtGGnM8zzpsaBFZySXXwcWMZVYDaqVfWPDDBNOWDY0mmgovz9+9kgYs2LuQAxv48+GgfWNZ4Y8X9TBGxdwJgaQSAFB5QPOAbIooD4pIPQS+jmPP5A9JG/z9/fC44pcu/u/seQgpXW8dn0v938hlil/+l3dK2Nkh7mt/6pKmH6qMa9+/9hT4Jp+PJJ9eF/8j/rWs/9jCro9397+Pmbr+j6HCum9y8XWLltxOBNxJMMcQ34bhfr9wSyeg/lceyFThNPiP3YecSrYoHjRX2DSIXe3vmZf3roj/5An5fqsGHvK0mZXdR+1JkzWrMUi/J/nxwXYuLq61/DvWgfotRRjTR73JPg/pGHz1WXu8DJlLHv2sO8tXlH9xAMgF5KL+v4hpAeO6sqpzN63jebaud4VuO+Wdb8t37tfFh+6DOf0nnSCnrFQ0MM6Dj2+Y4fARYSqNVgV/NsgBzZn9c82j4ExOejyo8mytqLIBrCx36FU0M8+r3L+nxB54m9qHWG2xjtmLFyQ0jiBvbbc3nlDg8/+GBYrjfUDy9dVbvXq2rT3V2tNZh7dXvqDz7G+qnTGhd5sM6fOi386xsX1Ccnx4Z1miHiGkiHJIkgGCsdYEg7rvLolWtCX+UndF9JkIjdZz8Xlq++BjRSTfjfEjZaCg3VJQhqzu2vfyUsHz2tGPDzP/crYZmYiGNApS0n9F7gyxWcP/jRci/mbRmsNfsV1UMBY217W4iawwtD5Mwjx9Q2S8tq41cv3AzLU5PanxvHu5ZqSee7efN7Yfm1F4RS4ibz0SWN3X5JyKCX33gjLLcxwX/8b6leZw9pLVuqMJEaPa1cezssYwpzXHA6GzWgilvqA7Mf/emwPHX4kbB89qkPh+XXzqv//Nn/8ydhudbXuEzPKn77ddXXTF77c2NY12ytDbFiHt7tnb9yLSxv3lMsPHFEfWYmo/a6fFnvqVbrGtMDJKkDtG8fKKV6QzH+nTf0/q84ifcAyIFj2LspTmhvOA2GaAQBhvjF9zrUBN6ftG5fw190n7PHjoVlt6txVsM+16V3vh+Wd/D+aWZM69FbVxHP9p4rAezZoRm1TQVYwQrGdhPzIlG+RF8HWOtGtjzxP9zbHrj7HhLB1hPZ7I64B0VkH/DAYyL/F5Z8xNSPHlfbPLGkur4MwuIXL6uO/uiWBv4sJoJfP6v7mcEW79dX9N1r68Pyp0/o2KkM9zOB8EKfjWP/voJXTXjt4rTRH+ogSyYS2EvH+vIN0X+c87eAuy5insY6vKLXCU4CHSiN9XBk+RrTdTPI/2YLKn9kSeUG9t++jOe6rpTAeRSYpDj7M/rwMby6m/L0XCf38KmHi6hXnIPxawqvkE/jteCD21jDoH3G+xrHh9OK/29VdTMe9u75W5PIq+AD8MPuQYglaLRHq8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJ9D5lP4wxmUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMn0g9a4opcOLsnRrwcKrCZtLYg5aXfkSJWARGMASmRbwxCrFYY+VggVoFbbNA1h7xWERRmut++fpweqsF7EEgx1pSuWlRyd1/XHZKgY92E+7tEHXOdstXWsZiIYYMAsXW7AQh11Zp6fvTsRlG9ZKyH/omyXV65W3ZWe5dkG2bTfuyZspBTvxiYKe5bknHgvLR6b07G/98y+H5e9chccTPMWPHhUG4pN/+wth+c3OS2G5MRh+t7qrcycT6Act+TjdKL0clkuB7Blzs2iTU7B782SZ5sRgSQx0QLsL20/85otIGuJD6Evei/qEjaDgIw3EmQs00cSS+smTj50My6+fB76lrjoiquOdt2UxeurhM2E5kYCXFuxnaX3YbcjuantbFnZje+N4LK97TKBPEc/W6+mEtLVnq2STun4HXAlilRK+vrwwCYt4WOilI3b3f9U+2HEcB+QSpw0b+T7uiNgMOnh3Ya3fwnl89Nv5rMbFVEH9vInv1hE/iLmg7e7MjBAPvq/6KZeGY21jQ7ZkJKTkUkSKqE1qePByEzgyjI8EsFe1OhAXO7KFnEJ7ukAgOK6eNWDjEsXRgmVswRk5/exnPx+Wn3vu+bD8zxKKteWtlbB844qsM0vw0Hv0mWfDcg8W0SnMZ5k8MS1AhaAt26jrNMp3V4Uc6beHbeZ6wJZg3PiB6r/jyl7Uhdd9BLZD671ITIUlpcO5Hoc4tL6DPSXOX4XlJmiATgwxyEE/ZD4wwDHJGLCPiA3E6KTwXZAhnR7qKgmEUxeoryztEVH3fJbBnjX1xhbGx5R8i6fmZsPy2h3YW/tq+5/7wq+G5Yce+2hYHp9Q3uKi7mMRZBJsBw+wAI3hfwK0NO1GR1H9hDAcCeRM7NtEFvWRr7po06CjYxgP/bTaII7zB0Bs0K42M675sgNr9VoJ/XlvrLsY2z7sbD2cr4M5IIM5o4Ock/MlhoTTrciGOZiGtW0MaKnY/pNtAEv+YED7WfRsD3WDYckYM+jKRrrT5j0DsYR5PQbcJvtznzhUIFBrwBTEMF6cKj6/Lstqb3vYDtlJ5bPxpL5X2VB+3d5Q/OzVlaP6OeWiExO630Jc99Xp6t7bHWCSskBt1VT3tarqGM3s9Ik7G22Xemd6SvXSaAOTiz4zgNdpqwYcJ45pAkF0+64QOkTBjhVQRoXlx5XzcV3W69JvHm2z97kHSGYH6wiuFybHgb0tK17E4CFbaWp+bwGdSaviNGzbu8hFiXBiPhwxfuVSJtj/mEPzM2F5YlzzDO2lkxhnszOy/N7cUZyK+8oD+tgq2NoRnqJWVe4/MaH9Ah/nL5dgcV3WGvDQoWHuemRZ6NZOR9e/cVdzYdBXW3Yxj99ZEyIgl1X+FQeuKoEy6zgG/NQA8Zy5TSTfiGAoR3y9CBxgBFcUP6B8IEoJZaxf+N0DUU2J94BngoVysHe8mzjgfAcioZwDPufxRNKp7QqIx8xL/20Alhptjdc/+GP1t1JVN/2P/hs9zNIDWOPG3/8dsatOTOicn/9V3c9THx3ew2//d4ql//z3sbfXHPHJZ4TF7rmJtlhDbn0q0JwzgQbbQfzZ8NU2u5gv29hfnYFNeAnX6gearzaw1I7H9o9j93PaLvYDYlyr9XRffeyPHD6uNe1jj2ttvLGNXBhbjNNTmmPu4Q+dGvaYkYt6SHDHC8o3UkDbJ5DT1oBRaAF1G3O5f4s9kqS83pN5nSdT1Dqjs3k1LG9fE94kl1XuQQRfrc69WR1z7uhh3Q/2Kwu5YW7zNphyZ5OaFx0gegYlzekB9sS4V+1iv2j7jBAhtRc1R9y+rTy9vgX0ITaw4hc07zvncYxDjfa86GE0lnfU7gWs88YzWsNVK8ovbt4U8riNPI9rogTwQgHGdNcjVxD7jG21+6uXlEuVMEb799uyoz4+tizM69GM7oX7tbtYA/WAmKhf0DPduqsxsVlUfzh2Tue8t6K9rGROORbrwC3p/NurN8Nyrq58L37zgo7ZfS4sx5AbX/dUB4sl3edzgXLEb2E9/16UQNwMsJe0cktruocfXAzLxZ7y4eTscLxOzajNrr6mfZy7N4SSOQTcWdJTn/BjwmIdHdcNNM9o73Z3V5/HsV9axlpkC2uYNtYWb7wu1NVZ5M/fe1P19Im/9Uln5IR3gUngXHvY8ygAAd3GO72Fw8KdPfO80PaTi5oTdpp4N4S9U74LiGHeiMWApK4qrl5959WwPD423JDeRex4YVP7LDeB250tam77jdPqXxtXdF9zQKE0WhpPmyWNg15H4/joGY2DlSvC8p1KLIdlbB85g776TxDZy1M5kxGrJptVuQIcLuvs8DG9H+qgXq/f0t5JcV5jKJ7QOd0M3lF01J4/vHJDz/LYx8Jy+5LmpUJ6+N20o/oo5NU/Th0RorHFd9RtxGHMkX3yjaOLOxSxPmAZa6EA63C+d+RMSJz9KCrGhTFETA3L3Jt7BO8aW2uKY394TXs337qsvn1hR30pgVr6tZO6h9PawnC+KIKh8y2glH5jjxqXRLtcvge0D7BHO+oOzo2arvmypoAIVgn0pMh8/ey0vruUV/m12+pXu9j7O43Xp1f0ut65jqE4gfXuWFLfXQCmKAeMOpGm6SQQRGnV3yeX9fnbyCVe1pamc1bbNZGYkcSCBVtezlGsle8jmSqoKCKTung3msLz4bVj5J3prV2glybxhxzeUyJPCCKIM66w+G5p//EdvIcc1RxjTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwfSNkPY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMH0i9K0op5cMCfExWg5mkLGq6A9iP9VRuwkoy7uP3N32VvUAWOHBWd7qwTGvBBsuF7WcfVjpxIET8PZRRtSL/ID+la/ZT8ks68rys7OLANxGf1KvoWTuw+O7VVE4S64Q6u16TJV57APv3lmzayFyAI7fzQELWU5c7Ov/bW7ATmhWCIZaS9drOup69si3bv8S4nv3iV/7vsPxHX5GN2YoOd+Lw6B+flSfUDVgiNpaAw2nd/56em9bZb70k21H/sHylikfVb4rj8oyKndV5Nq7r3t94ReeslOVJ1SQFipZm8GyKRWyU0J+80bYAjSJKYC9FNEpB3lgnT8ty79CssFW3VmT1R+zCPVjWl9ZkXzczoT7mJITtYN01d9Sft7dl5Zja6z/jWXlsVYHeWYdtex2WrTXYy0/l1Afo+hvAkp9tOg870DzRE00cj/iV83XdEgZjqaVypYPvwrWLMYhWeR4Gcg2xJAn7vWJWbTiW1316sNtuwvq3DytDF9dNwQI2X5QN8O7usG7rsCemRVoCMTMGDkatpOPjGBMRhBSe1Y8TiaG+6CAGBI7aJGI12NE4durqf8Eu/N5gqTcqouX69LTGx2/+5n8Wlrc274bl//If63O/IxvNbksxu15VXVRhgfvAI7IMvX5RcbcCnAjxI6vrOn+pQiTEsL95iCMZV20dwCab81lAZhq+2+vxN7W0WMT8zlhLtA9cKxl1e/h8AJtL2ja6sF8lFyFAvyJaBi7fEYxHDFaiIDo6LuxGAz4XsAsOMCFx8E0QqpwG7BTv5zCXr8iS+L5dtuM4zuy0cBer65qAH3zyXFj+iY/KCpeYimZdc30MiAkfGAwPQSs4ABJAO2MiK90DLDZHRXCKdfodtYsHO+JkQTw2IpaYl7rob33Yr8cxSXpApdGitlPXnDqA7W0GSM4ObHJr1eHYbaFP5YHWYlbex3Uqu4oXtJSnZWg8wZQeKDzk415C9rMRnpaLHHgAC15ixJqKU0FPzxSL6/ytho7p1IEdyxLfh7iC2NOHva6LRUEEEwbUXBPINS8ADgXtWb/wuo6vD3OhscUT4WfxjOpj55Z8W7u7ymuyReZZwFcWMY921Sb4agQzRctauOA7GeQhpP4k0UfbfcSgEdQMkDxbqIByWf22BZRZA6gjxiXmcw1YIq8gR53A2MosKO/N5GTbHEfFV5EHdTkP7LVHC6iuRhP3CJxkDvmkh1jbbKrfcTixTNRfHkioel3XymWYu6p8bUVzOt1ha7gukWgDoqBQr2NF5e/lkmIWSAtOPqN+fmdNeVgM824e9tWtjq5V41zkci5Svz16TOuSM6dPOY7jOBmg1BpAaNDiu14HfgDYyR2sL6/dkq0989sMMHVuTPceuDoPUYLETMWQx1IjThh0HJ/ey/g8ghpCchRBKe2PQOI6OuB5GJbwXSKW3IPQRz7yvPtYJeCViGMKcB03joHA68f3v/fIRktajVcocKz8u2vUDta4X/zXGse37qiiPv8rKv/ULwDDe4RI8R8NscR8m2jf5aPDe/iH/zVx4er7f/Q7WIv2R9sWftT0EmJ/FXGGtbhD93CiEJDDdYHPSOOcaXT0TYzRMvYM+p39+wnXgxG07l45h7GYwdjarOv6vUDlR8aE6nFc5L9tzSWHZjT/DQZCXwTAv03OKWf3q8rxeph3M0Dn5XJABm4qT2ggJxug7rmf0m4jUHQ0L7qe9kUZvlIV+e/3qrpWHZNzLq+56ycefyYsP/7Mh8PyJz76IZ0UOfA7/eHV3kE+0IprTZJNILYf0gbJAIjDAHlmAj1t6TDQzLDtf/1l7RHuxLT/x+WiG0lunB9LffKjnw7L5y+8GZYfO346LJ9ZPhWWczG1wffSr4RlP4E+3AefB9jZfj9Sefoc91NDXnr7NvbE0X+eXh6uVY6c0H35GAcxxPHdTY2zpXnhllY3lEPm5oBfJ8KL62RP11+YEQbmqy9f0fFAjd19W/2nUVL/efaxh/X5He1/vP2db+p+sC68+cqf6bneEErzKPY5L0+rHg4iWvLjiaJiw/Kx42GZOXwAZEM/rX3U5UPDur23prz09jWsJbA+6NZU97V17dV11r4XlrnmqQIpslPWvTRKWjP72Ev2gf1h37pxQ3n3euk6jh/x9eK81uCTM0LVbW1qHAR4/7e1pv7gJ5SbJMbVbx1gs5JpvbNKDFR3lR0ggsrYP8CapYe9hM6sYuzy4084juM49bowRq8DyYWliZPHO9OvA1XHjc4jE7rmPeyzbHCBgc97XfWN6pbO+e2va65qYwPBBcJtgDyhi32WVFIxrjim9RHXzG3sa62CObPjai66fkfos2tf+kZYXttU/UwVgORd0x75bkMxtIrcuAbccmkPL+X3tLdwYkFj+9Cc9h+6WJe2sF/bxdq4g88jiHDueXLBTZQSJ0DM3bEDAlJwQJwaFbnvAQ3MdwQJxM5sTvX4KpBwKV+xdiuj2NjZUbsfGdd5CsAO/ckt1e8/u6g2+CTSy+reO4jfO69jbzVU3sG7tyrGHKmw3AuK1AD+B4Qi5xGkilfWdaIbuG4hp4Ne17TrfAn7fbtAEM0hxucRsn/+OHBVQPlNAFnkIz8nVsnHOuBjs/r8VVBD8ROGyDOSHt07YJn9YmX4hfObijUfXsQBpJHh3LmE/tBBf7rTVNyebSr32MbeLLso8WVEJkXeFeF2IsP1PSSvo/3Ww2QymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkep+yH8aYTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymT6QeleUElzfHNqyN2BvRqtP2pvFM7Agpk0/rC0TCVkOuR4wJjuy3o7DTp32OQFsrTxYxnn3UUYp2LyPyd6p3tNDxcEWcYGG8PC5VwRyoS7voTHYeOa7On+XqAo8X4DvplrE/IRFpwNL0hv4zdJiVnZl5+/IOnpA+/EC7NAKsnBz0FavXLwUlt+8Kduzb78DjEdb5zx6XBZyk/PAPfiyuqungQ7Ys0LtdmX7eR2YprvnZfU58SywMnN61kxKNkqxY2r7SkOWdwNPbdiDHdSAeA8iE5LoH+BsEBMRi0d8l0dPB9hFOa7GmevLi2xiXtaEJ5ZlMbe7rbE1Oa66dmApVoId53RbxzsJWUy6MfWxgPZVxC70+nv/RYygHRYsmQewDpzOyfYwBZuxtbLGWRO2wlMF1UEKKAkXGIoCbPAnYHHooq+ub8jrbOuO4ke5C4uyPq269HmPsQl9shPTs6w1dM8gNTkZxMoWbFnrQLdNjTPG6fh0TlZjXdhr+nt9vhhpY12fVqwd+KXlB3q+LOxckwnE7Tjt73T9VBa2Z7BivY/xcRzHcXqysQxqwCetyiazcVvlnGgyIyMfCBSasqXTitNLh2Uj+A9+8z8Py2+8KlvVb3/tT8Nytap6mV08EpaJ/5mYUAxOZjT/3AN+Z6eiOEm71fuhruDr71nY2jW6eiYfn9NqMIjYTWps9SKxCZbBQcQTPJQHPJMXOR44G/TDKEpJ9xnzEPtgKe+76udtpDjtAfotbMGJiknhPLQWdx3GOMzxmFvSaVgi9jnWh59zPF+9ofk3m5UV7KPPfjwsf+Zzf0fH5BTbiYnpO3+9BWbE1hD3TkvBPmJDq6UYxDgxikoC/eGif/bayktc9KsYEEvkQRC9FMMc0tzV2Or35UPpJpRvEavUb+m6xBolYFebaA/rutEAvgXoz1RWz9SCxSyRLcxXerAJjSV1/VSNiCfN425GSJUIgqW/v7XsAFglBjwfVsWDjuqmU9O1GIN4nx30sSCmuideYNDVeXo4TxsLE9AGI4g/Ht8B4qXdGJ5zoCnG6XuK27d/INxnHLFm8oRsybO493QccRBY2T5ynnxW/aAfoJ/h5j0gW1JEiWDtFPffw1j/G1SxqP6QyyrH2thU36jWlG/1kXdEEB8RHBjyvw3157Gc7HizQIlNFNSWtP7nPNoGhjCZHNY75yTeV7mi++32gI0EpqkDW2pioKKRE3lVSve4CzxaFcccmRNiog9r7NvA5FaBfMrvL4gAACAASURBVIoBrdEEU7ZSAcaqrVhWQG43MaF2i8WxzsITxJJqT6L8ymXdT6Op2DML+/HpaaGu0hk9e2pvfRxzGV+A7gAew0/p+l1g6YhErAOBd+m6LOUHyEOWFuTFTFRTgsg8ev9GEI1YL8bedevkb15xYk2JTHLedznged4DSol7G5F/guUfUL6PTQI+iddxMc4dEq547gg2inEU9vJJlcfG1N9d7GW9F7vlf1PqITa9/Lrm4DfP68H++P/Ug/3Hv6nyJ35BdVIoEEd3kN79ufrItWst5sjv+jXTu2h3wHmOfVJ13UYFdyJEL9jXIy61sb6oAUsZaacDmLUkqDG9J2o5tTcuC1gLZnNap4ylVK4iL01hLyPmArPOfVeMy1ZD352bFeJlclrzn4f19q0V4VgCF/ucXZ1/C3NSLyALTvXURc7OfUAucZvbt8Oy72AzHAcxTrDqyxXtJZVefiEs31jV/b/xjhCfDz/0qK77xMeG1zyiPQQ24AA5Q7ABb3xgJwcO9lZmVZc9IICKKWAtqsJyxDLY89ufBnSgRj1MPL0kfMtD8/L+376lfepYWXnS/PihsLw4re9eX9Ue+AB9O+EBeVXQftjkpNZcaeQdg4xqbGFeucnMlPZsTz35UcdxHCdTVE7F9W2/DHRYVSjYGys39UxY4+QndZ5nHlS/I2ZkekaI8PgT2mv63m0ds3pV+KS1FV13/tjZsFyc0nlSwFi+/ke/G5bHJpXnda4I1dQH6mQB73DS41j0HdDhmGM/94xwTg8/9WRYfvuK9mBKwDB/6Cntnc8WhmP9O18ROme8qGfKbijP7LTUb8or3wrLvS3FEe6hjSGknF9RTjs2pvoYy2vPPd1WHNzGPnE1UHkMa5T1GjGRo6fr77wWlm9dEtYsEpux357C/moTewAD7Glx/4B49elJtWk8rn7Y7mi8JpKau8bHNP4On9C4P3XuMcdxHKcBHsvVi+qzNaBgc1mN8w0P70zjOmasondvt1bUf0ACcuKY/zqI096scvxNoIuZA6TwTtYNuN8AhKGjz2em1beJ6t3ZERPm0vkXw/LHPvZsWP7Mp4V7f/Ftja3z94iPxhoKa7c8cDzxrmKr01nV/e/NgZt4PzWZ1fw+hzZbmle50VAbE11Xwp5bG+Of+QBJSgHyB86FxCcFmKcj76tHfGaMkpT232eKxbiHQSyX6vcO9miOnzwZlpfPaB7NTaqPjacVr34X74DWNjQW6oEGw8Wq7uFbrw0/vwPMsosc2QdOuRdwjwH7/VgozXPvH3UwkddBMzjmlTL2lFCBxYzK1yrqAzcR79uIWWt418E08+ZlfX5qVfdwKqlneW5Rx5wAbonrDG55324CtYr9WGzpRNBHDcTfO/jdQqk/bP8/v6NzTKX1rEcncC84H15dOg38YaOn/fE7yeWw3MR+qetgjEbGmdozOGDlyx5tKCWTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwm0/9vZT+MMZlMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDJ9IPWufsDlsmy+JsdlP+YBjdHrwHYfdvGgHDiDmKxruhGzM6AcGrIG7ME6OurfqHLch2VSRudspIY2W+2ELLO6XVnwBIP9ba9ohzWADXq/CQte/I6IyIixrD6vw8q7CAv6LL7b6MNaHeii3Jy+m4AN1DLsht1NeR6VYFnfqABhU0a5pvO/XZN1WAceUr2jsnwbg338oKB7eLshy8CJs7Le9mEbNdizq7r7fdmorb0u2zNiH7Yu6DmSsE4ew3OPLem+pk/qfueu6Pmam7DVRz15GZ0nlda1PA/ogIjVOvvlCCo4YExweMRgU16QVd6xo7IMfe112TpmUC+LC7LXTKAPBLDXjPF3dDHZa2ZhE3poRn3j1tWhJV61phiR81XP42m1RT4JK3PY1Cdgqx8HMm2mBywQkWywe0PYcaZgF3/0xOGwXN+SJX8TaItyRxbboKA5rrO/LTKvlYTleNxX/XXR33rwGY/B7jCbV5ssL6k9cwVZF88vqD1ZJ7GI1fvwv6zLZgu4FCA6enQoTwDZBEvBXEafu7j3qRlZFiZ8xf8A9uBuV3UZNGX9G9xVX6xfvxmWtzdk26heNjqKIYZ0OvvjDAZAeTz99IfC8uOPyrr23h3FyZd+8N2wvHRY2I5aSXWxAQTEiVOnw/LK6kthud9n/1Q/TO+Nu0IK4wPjOYE+68KmldaEGHIR+9IICuGg39pG7KphWQ+7ySTm9H6X9qg0wsN5UKYdPbFsPRfIiwGeFzlBzocVHywXaS3eQXtypkgi3iQz6v/zC4qJzT18y25N33z8mafD8ue/8Oth+cFzD4XlFPARkSqIZG2KFwHiSyxiB4o+gc/puUo0ZR6YjVGfF9Owq+bzd4EmawMvFnSBXirw+XXOXhv9p4PA3qeVI+aonNpp0FHe2W/DYhtzbXKP/9jHxNIAsqUHW/gaPk+kFIPjmPO2t3XN3kBWpsRM5ZdktZscQ3/nuOkzT3b0OfJhjq0goTmpX1ec6gAZ1mrBFpkogLqesY/1xAD5eQ92yW22SQBLZczN3Y6+Wy8jbwEGsDAzxNTF0+o3fVynw3kLucrA1frEa8Pq12GsBEaHaE7kU3W41GeR93I9ATqbM0BDMMaNosbHlWNNwR797upmWO7s0PIZiDPMncz5Wmgbzm237mpd4QMlcXhO95BCLlOtY32JapxODvtwEjbatOn2gdjh9ZNopHFgbAeBrtOGH3YTtvAV3gvO2YHl84tvKk+aAfrT41oa6+Qs8rx8TvG7CPziD1+VXXn7tr776EPKJYiI4pogh/XE4pzs3cfzGouVmp7rEJBFq6uyw46D3ZHei2f37mo8tYD+LRZ1nT7QIb206qPVUJxvASHVRP7eGQiTUEWOPzspxNMM8thMDusJxKwuEqBeP8KZHj158EYmOyWCGkL5QBzRAfik+Hs4JsJs2R+PFMUquX/1swOwSkQ2Re43dsDxiBFOSu2YKyJ/B/plFEJtp6t7fuVVWPf/lhrr8y/o4f/+f6HywhLRYDwr5jSUdxvD8u//tr73tX+xP1rR9KMpxn0CfN7nNs4BiFNa3CfweTuCe+MeHOZUfDeGcRHHH4hSQprkpPY6TQJ5UjclC/w0WGbFScXjAlBK28A7NDs6+TZygNKu5obcmPY1BsCSPP/xZ8KyC4Td3TtCyJQ2lWPstjh4kVchr0glkHsjp230uI4EJpNEJuK6idsl8hftUwYapHRT+6iXb94My1/786+G5Wd/a5hP/GxRaCk/R4apbsY7IkSIg1yFuKcW7utFV7lBBfnR6QVg7oEKdTSNRhXBR/z4qHT9QlguLGmfZfqYsFWXX34lLP/ut1WuYoy2gUVvVrHm66l88ozaZn5O5/ewz5Ge1Hj5qY99LCzPIPcZ28MRNbHNcvmWkFy9tWtheRf43FpN46yFfbcukJeVWSEuspPKgVJJ5Q/FKeV4sYTKtV2t+XysHePArE1MqQ+PTaq/Xfnal8JysoH9eUz+bl/32QKmtpdT3fylDfCwdGLxWFh+YBFYqK6Or+yqc3cx15YvCAvVzA/HYveO1hunHhCaqYwc3GvqfdkAmJj0BHKxvp5jzlUO+cufUJ35WC/e2FT5zbdV31wX5Se0S5pOay3yM2dV96OoZEbzRhJo6jh4Gz7KhXGtQabQVxMJ7seqH3K9NjkvPP30ItZ6wJDdWdF+dAl9u9PWvHT/PWHAXUCgjlJZtcUU2iXWU1++uqH1zvSEnvuJE7rHvq9xtjinOHLq6LLO2dU5L65hXz0SkHGf2AuNA6nXB9I5i/s/NKv1UamsuBIbAC+8o7XVyhbedVTxfiaFPTqsL5Oejlk+rPacX9BY6LR03e4epryNddgq9haWZ/BOCntfh2bUb+6saX/gJvKHLrHOyJsG7v7z++CAd3AB1qn9CEpptOXjPRL3BPt874i9uSwQVvfuAcPoARmfxLyBvG1mXvMu6zoH3NlMSed8+823wvKbJcW97l6u5uEkxHAXs7r+NPBD0576+/RA8eLhAvYeiTbFbxlu3FV9tJErTuZVHz+5CIyR0j2ngKF4HilW/YB9+9Wuzrm+C4QU8oCvK0w5f/esjnkMU+TLSqWdlbaOWccWRjGFvBdtUsK1dvD+5H7DvbqjfpO4prr55YzKWBI49wZqn9KY2vvMiUd0fbx/aJW0YRp5dxFZju4/uvj+i8VY4P7Vg/+SzDHGZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyfSBlP0wxmQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8n0gdS7opSu3rwclhuzsMQbh4U67Ca7sJGKw7YrC0ujnpyWnN1tWc/1YL/uwiY3iAG7kJOtTjsvy8JGHJ5A7tBjxwU2hPaifkIWW/GYbID6sLpuNuVz5AV6DlqTJmAd2MsQkyR7M/rzu2mVU/EEDoFlU0fPQRRVf1rWQscnVF6FpWYiBvu5tp5xc0t13IQXo0vsCtrKgwVoHHapXgrol5jqp1OXrdrVr94c3tcPZOs2oFU4LI+CdZ3v9oth0Ul21G7zZ3Sd9Aws9WDnmED/6KAdEqn9263T1v3S8p9Iq5FUAO+tAIPIpacUnjmtMXrkqGzNk8AXrW2qnYp5fffwguzX5+rL+m4R1/JkxefnZLk3CfvAW3vt3cbYysPulRZbrkckkO6xD9u82TE9twtUQRlYhlaXdue63yYsNLNj8hmLwUotvqG+0ejLoyyNfgsSjZPBGCqQnICfG9ZgYeyn9YyHZnUP+WmgkYCeyM3qeXMFWQCOT+i7LrE+qKt6fRgfaf/OeiW6IJdifwIuDn5lPfg+e4ihqYxsEnuIm0FF1qMO7BOdLVkfdu/JRrm8qzjVwjwyioogIGDv5kWs3miPh/4MS8HP/NwXwnKtLiTAyvWrOI/qYmJaaIMb12X3WirDbo7xG7eT2/PJjsG2r42xEudzwBqUv5ztMgTRv36wP0ppELAv9fc9JkaPO6LG4OdHCz3ajAdAehHT10WdxT3GRyAGgYjzgFLqwYLax9gd0CKT18Lnh2HZ+dTTj4fl7353iLqaHtdzPPrIubD84IPCJ8WRG9C+nmX2J9oI0kKVfTRqHEircH6X9u39fT8fSZESwX5b0DxEVE6zCpYNEoPcJLB1wAF2qqrr2j1h9/pN2TATSdAF8qdbV44aT/5Vm/McsJvEgjXxvTbmg8Kk5nSilJhjpYE26bWVi3ZhsR3hRtESvc92h418V/NiH5g19p8WECXtOr7b1/l3YYOaLeneMjHNJ31Y2na7PL/urdPXGOkA49Fs6Lpbu4qnHmxiq3uW2a0a7LKRw1ZhqZ121Q7O7YthMTeve0lmOZ50eBMoOBf2pTHYFntpxFygRgLEL9qBxiJxdvSUy2nMFYuKhZNTKrNdeg3GNKLzkHeQ84huWwND6+Y95bE9xPVsGhg9nAfDJbQ7LmIsttAHOGvVquonkxNAF2XVfxsY/+s7ihEtrGtWVpUbpYBwSgHPdPOu8k+ihVOwCu5GcgxVTgHYzQywQ8eWtQ74xvdeDcv9N3Se5SUds7iocgZYsRgwteMFrUdTGbV/FdheziG0uN7eywXrwHoWgWVNIi9tNlX3rZZixw5Qc0lYNx8BjtIHnreJ6WxlU+1Qxfk5104g184AbRgH/nQkhb2NyAKY2CMydpjoHYRJ8g84xjvg/D4/R8WT2ULE0v3jvX0++8vneC/3GKHNYNADb5vOKB/wXKEneiOc95QrepY/+B3d59o9PfA/+u/VP0+cgk068r+NkmLoH/z2cAz+3v+osdhqMHc2vW8xt8bHBzqD4yhazTddroOAkt+fNOvEOS6xz8iPE1x+EXXpDGOpH1f8KyC/rgEHODkuDMLSgvaCLt/SHFBCnF6c0uef/KkHwnI60Dx+8bzys35J2JhDKY3djY7idwfjvod1Zxr7XR6XTY76fhqI0hZwxX3Or0QpoVFiqDPf238flcj2DrCkbP+pCc17i3uxex77kz2iJvNA7EbCFP4H6+cYEp4nYzrnVwOV/Zhy3QQTpGD/NWJE/JwddgQVFFTPm2vqV9PHhZPsZJXTpF3VUaemPap2W+XOAKh44BhuXHo7LGP73AkammeOHhOWZwbYy8NLwv+kCsP2LpV0zdmC+lr5pvLMdhXxO65cK5PAmgUB48L518JyYW45LG9vKf986x3tR201ke/pkZzJvOJEC+Pv6pqe9URG6+ok6tgFrmMCew9F7L/kJhRX3KL2weJ4xjMnhaKZiGtf8s3z2md85iF9FyRlJz13NixXNoU4r94YrvmPTR0NPzs6pdzyck65NpOSbkYop+a2UCApjlHiy4Fg7dQQ12pA0la0hl/fUpvPY51/bF7PvTjJZGj09NBjz4blNt7LtJvESndQRjxsaCy89kNh6KsNcUM2N9TufLf21JOPheXlKd3Dn/3ZF8Py6+ff0XfbGF97+z6R2D2jmOL2NSpm8G6qsaX7amCNOlXUd88COxZHH8+PqQ9MjmkM3Ue0D28I62fuf+IdYSqD97ZAO8XieK+C9zCpJLA4WEPdXRWCKJfQXHHhit4X390GgrgnjBxzyn5NSKlGRXGiP62YyGfZ3h6uFxvoH3er6gc7hxWDFucUL3JA3I8Be851oXvAe4/3ogi4kfikEV5D/GUVgK/h+7ou8hXuS6WSKt+4LexRIa9699CXnAgq1Nm3HCNCDTnZuTHdwx1840Ru2GbE3i7Mqr8XUnqOT5xRH0jhPVW8AtQm5ugW8q3X9XjO6+p6kfcSnzmhz59dUh+YxzbBXaW3TqDUw3mnifcJfHmI52qzHVCXlxs66A+u6wFWsUb8DnBLjUDHfH1V373XwR4J2v+buM86fmMwtfc7hCbWKld9ja2vtdCfWmrLU08q3v7izyj3z44rDr59QbjL2juKw/0mduMwXiPIsoNSVG51uN7+B0HmGGMymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lk+kDKfhhjMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZPpA6l1RSlnYS6/tyE+o0pQV5nFYLydgfezDdjMLO+cK7L9oe+PB03MQl19RPavrdpOyQwPhyIkD6xDsWWYT/ZFKy24vBjyQ04PFZUP2QfTdieCh4KdZiOnzMm0S8VujeE43mcDz9WFn6WRgX9/X8f2O7J7afT33As7fwrNswsq+UYclcEIWTJkx2Rsl0T5xV+chXiOBSu47sBgt6Zzv/KEsTzfPD63+UDVOH/ZbDdjZxXyijtTPbrwmi7eNG+orR46oDzV3YIVF2/Oe6rUFq3XQcpwBbKucLqy+BqNtAeoMgAsDysphf+bv3GBrNT0vi765Gdny3bghSzzah/f7at8+LNGdLnAMnmz5YgmN+8kpfe7t2fvRmqsNK3iiZ4gwoRsWrfTbTdj3Tus5+N1yDV5n8FjjeQLGhrxs/mcX9NzHZmR9uLOp8ZSGbVcaVp8gpTllxIxNNNvzZ+fD8uJRWW1mYZuYQ53EfMUtL04MEuId7ZVRD96epW0asc+DTRvxEhGaDfpQxDIYNndZIBNSiO3Viiwn00AmJWjRvKZ4XquobzVomdkfbWQEx0eno3Iyqbqu1VUXGSAG4oi7Tz31obA8f0h21P/Df/tfheULb8qG9dgp+fWtrctutUvUAvhJEcf6+2MRcZE4rTg6gQ8LRDhwO52B+l0PlnwerHM5dge0rINdbsylXTUQDWSRoM9ErO8wB/uR7IWWiCr3HcQynD4d1z34MY4bnhITGRFLHIs4npadJWDq4ns4GRdejYuHZS/qY2xFLD1ZJhqJjeLSenF/y/aIpWfEUlBlmod2YFU68sgIPFucNpTA86RhUd3cka9kACxQgDHdayrvYNzzMsqfqquKb0nkIImMxo4XU17Tbcqq/L4FJ6/pZ2WBXAJilMjA/LhibQCszsSU4ouLQZEZ0zmJxxrguWO4R9qg9zqwdoaVMPPSbhsIQ8y75ZKetQYUVKulespsqY676JQD2lH3mIerXAN65ep14a3WVzVnl8vAWGHsxPfGThz9xsM8jtt1ivAKT8gh1okd0h8Ch7geHI98v93WH/Jx4DsD9RUfI5BYnHYXc+eI56gF2DzPTAOvUNY8X62qXe7cU/7Z7uyfu0csUCNIPf2hDmzuVln9ttHcP5bWkY+WasPjl+aUt7bRkMwVB7iZCnBhOWJbdbtOp0MQk9SAlS/tquNo9yyshHm/7BtJfHeqqPsfB3aTVuTLwAs9VlJOe/UWvIKhCtqNSM6VOxpzm7uKDZyLSsBOpdK6z+1txd/78/r8vPLiNGLs7q7m0FJZY7vVUBsTPbiwoL2I6SlZ8w4QZ5nT1qp6vq2y6qPauBKWTyzLQn9+VniDzKj/myJyQzgvMl9gOCECwzsgSaAD8YFlHk+uywGIJX8ftICm7ndBMx1wX0xXIs+H68CWeuCMNm7grxNxg1/91xrrTexz/L1/rEpZ29Tx//IPFFd++M3hdxvV0cbY/ngqYhivErC6tGVnV+U308gFJ4CwI1Jvt6LckcspYpW4bEr7QP74yhcrveG1UrhH2rkTTcH17cKcyhUgru/cUnw9d1YW6ifnz4TlwrjmsMNFebi/c1dIjDMpzRXNjp711lvKJRLAjHJ+6HCPgfiWIvYWMfd3sPXVw/znI7bmsedNLLCLems0VQ99YDRywJ62gE1aqA6Pjw+45sO5mS/jmQLcewxrUZ/rP+BM13Ff914V9qc2c1jHA5t9UL+MarTxERMzSuRv3lBOUdtUHzu1dCgs/8yD6qsvfffPw/Kdvtorm1M7juf0/Leqyo2q28plOi1gcLCe8jpaE1W3gFHeu1anoZzq8ePaM3z1BSFJrrYwnpN4v4HG295Uvnd3Q/d1ItA44F7J6t3rYbnrKUYcG9Nzx4ENvZXQeR44ofpOusrbvIKwJ/11jfUM4sok0PPBojBJbaztP/3Zz4bln3jmkbC8eUXteX1L+9atvur4xp2bYXmio9w421Es8QbDfTbvsOKOP6Y949fW1X4PLSCmLGpvz53VXu/6G3+q82CfpdxUTOmqmpw89gs/9yn1xWs3tP+wualAdeOu2nZ5SXPEKOruLSG6usBBMdDEOUdyn7qtfnvpvM7z5vlXwnILi/kgqbnl/Fuv6/ga1qCYRzMFrgexz9Earl+JpMzkVM8J7IVWrgi/7OC9Z7enZyJCe25S+1StFFBjCfUBIt27iPfECzHvnQCiL5XkviXKcWYE2PMHGhBEJqeMffu/eEkotp/71E+H5eKKxlztiu55taxyOqs4Me9oXegiPnI96O+9swjQTuWa9hMq2FsI5rC/g+dLoi7jyKfcCAKQa7u/HqsU2ZWJdFJgCP/as/zN6snHHw/La+saEzslzZFOr43i7bC8vau+ffKk8jnu1xC7ftAuFvPhzJj2jyqu4v2vnlKff25heE4PeOb8OBHwmEOxV9nH5EbMJZeUfE28sqtjmtiHXJ5U/3n+CLB/CZUfPqzyyQV9d/GYyv/bWzrPxZry1TLeHQb4fQJXaCxfUortbHV0nhjwYbM5zd8vY7FcLSrn4z7tblfj8mNnhZt8/MmnHceJvnudwJ5LsYj5HZ0/mwd6kO+WgMnjPtX6OnBrK9hriuBmuQHwbwb/O+K7OyaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUwm0/uT/TDGZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyfSB1LuilHIZ2dXcXpd9cnsTdliwjj93WvZHHVfWOER4JIDwSAKr0nFhNZaQTZrjA8FAzAd+0pP3YD/UG1qyxZK0LIW1JuzIK7B8H/SIJKH1sqx5xtry/mmPw+6caCSYGxF/4PvAGMGizE3r+HwW1oGwZW+XZdd3cUd1kwhgDbqoOsiMyUaTFmEJoFkcoGXiHlAAHo6BdXjQ0r1d/L7s+kordRw//A/xGB1Yh3bbetYkbbNgaVYrqy7ru0Bn7aqtaA3arwGXA+upAXya3AHs02Af5RLB5R5k8DUigmWqE4PtINuLv3OLqQ9kYae3tCgLzivXZJlGt1WO0RgtXHuwqgtUjiXVt48/eDIsv/PDoZVgD/Z/NLqKY/w7sIvvw7KX9q1OwDiitsvCSq0Dq7MWrOwnu7CNXdVzLy7IHn1iSvZfzz60HJa//INLYfnmluy8llH1LdznPYzdhWWd/7FHz4XlVE7XCoL9LXhp/x+xhQMKw4VNIFEihT1sWr8P7AOxS7rFiE0wkVMuLINTSVizYai0gR2plnR+4mniwKnt3JM1WivS5ojzI/5zzQBxPQHUDNFEmSzwSYj3faL5EPeWloRJ+vwv/ydh+feb/2tY3tmVrV0yI0u640dkaet2ZXPZBHLkPvKpiX6UZoyMs9/pmF6HY1Ed3secF0QQSIodabCc2rhujEgQXLeHeZdjgv2NYZr2jB4iSw7u+H6EBARUBf4QdxUbSL9otWnpuv95JiaErWi2FBNv35DV5P3qadaBCVyXDTjxWhHs0XtQxAIU/dIjSuEAC2z2Y9pzJ4FH6/WZ24yeesDrxRDfPMSreEbPk4RlYxeYwDbwk/2+xpOHnCkGW/E4fDfru/put6N4O8Cc02mp7O9hUvpE+sFhMp7GeCZiB63Xx3jKwva3UlY8dmMcQ7La7cOym2iyAPbyfdx7s6q+2oVlb7eh524Cb9Ls6N5qNdgQN3X+9TXlsSCaOi3kiDsVtdVGSedf2UDeDlvfGCxSk6grHxiB5F64oW0q55sxMBHzaZ1jahzzLOIaY1OngxNh/GUD5LEH2H72IwhD5MkJzPuD0cZ+ZGB7PDOnPLOCcdZsqR27QJ+urmlu4/rBjyBX98cJeGgExjfGcq4Xd6u6h95enxmg7yRwTZJhUhnFFKKFKjU9RwdYwyTOwz5Oi+EMMEOTY4ov1YrGrIUXxQAAIABJREFU6FZZY47P52NSIkophvm71dZ3XSASjx4RLqBeR56AuMK+urah9llZFcaRdtst2BV3se7r93T+sTHZhd9/9vGCPuujLcuIOz2cr4j1zPi4bO2LY8q5iHlrImYRg7lbUr8sAjsXQz3d29JzdxCvD82of4+k0C4RpBEDFssHBcQDMUkHfc5r4ZjYAffA89y/B+5KHYh1ImLpgON5HuZAyF1rwK31f8Tca9TEfOLb31D/P/+25tp6XeO7UQPG+8f70UdaHnIsxpY+U3c0wCDSFjpoKq/59ewh7Sus1YGeB8KXe2Ae5goX640exutzD2l/orq3Nn/zttbr9QZiMOat+Skh7G7fBUYT89aZY4rNILA43/6uED4p2PanBuqzYyceDMtLwDDd3RTyrtFEPom53OsBpYSEgLkE52OOIcdlbgycIb67iPUfz9Po67vJhMZiMa2glM2oIioNHZPf2yN4CPu7KQS5AHsIvTtqHxf9wwFCO4rbxr41cpgW8rII0hgi1tKNYCLYYUd7H7VVUT+ZOyKc8cYl4VUmCsopnnpMfa+YUj1+93UhRHZaaqdf+/lfCstf/OqXw/L3Ll8Oyy7m2rXVe2F59ea1sPzgWSEpZmeGeUq2qPu6cUkonVdvKB/bYY7aAGIU66R7azo+iGtt/FBOeVVhRv3xyGHlotd3hVyIA0GbRO6azSufO3dMseHL/+pPwvJd5F7TyO3OEh2c1fi4kNS9Jcd0ziPHdczGtp5rAvnww5PYBKoqn2t2iPTW+K4iX80nh22VKWqcl146H5ZngGpbnFNMbmDNc+SIYlZmoPhcuvilsLy0JNzSOxeFrkrivdEcMHUPHtXnd27qmdbuqc1v3cI7gxFUDOvfJNbUfC/gIY/NAdlHLNAgLlzXidMarxXgYrcrmCPxeQobL5NAZKXHtD7KAEvX3XtPOIU5r6Omc7ZW1HYbZeGEitPY79/UvWxj7ZX3se+KPf7bl7WXuMV9LbwrKNc1RrmvR7y7h+P9BNZKwGZTXFenkhrf3a7m+O+8IHTVkw+rn8cHXLfrngddPfvYjOp7fB74X8THZEv3n0xn9+5dY6jW51pXY5h7w8QP+3hvxP13yuW+eOTz/cvOgZ/zPKM9L37s+Y+H5W3g5jeB3du4p3zry1/9Xlj2MYfMzGjcMI9to2241ggOSB2OHNc4vvLGq2H5hU3sM+59YWESbb2t+LdR1ufTeB8V474QkvDJccWgWlb97vy6+uwAmE6Qwx0X52c+xPcGWaANzyBV+wfP6vM7DZ3nu0CQVbZ1DKZ150JD9/PQuL5bdTX+Hnz+I2F54QEhs1Y3NF9WasCXIS88DYThFFDSTmrY5gtzc+FHeWCaEkCWuZE8GnvY2IvhO5DpacXzI4eXwzLR2jWseciMHQT7564R9NJ7GIsj/grSZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWR6f7IfxphMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZPpB6V5RSdkGWSrf+QjZ/tSbwOLCY9NKyzJo5BLtjT9Z6xEp0YQmZBJpoIiWPokZPx1eAKkhFXMV1nsSeV3rQlX1PJi6Ln3pVNmpwP3IC2AISQzAABqSehe9TDjZZbd17PK/fGo3BbrQ4Dv9QWHt5PaCddmVnVB/IKigNW0x/WR5MvVU8421Zr8XOAKUEa+EYLI3SsFD1YGPnu7CNa6ht77xKpIZs2OYfl3VWa2No59a4JxvBfl3td2JJFkknD8uCaXleCK5/8aIsKm/cUVt1qmqsPPyperSgd4gAcvA5ujktnema6o74b8Qa6vsRm+wYUTmwhkPZz6j/Ly2p3gNHNrb1ltq6B9xEAKs6sqrcAXAMQJnNPSgLtKefG9oKnv+BrCdpvZ5Ev+7EaUcPy15YmmVhrZnNy74tg2cd39J9rWyo/9Cafndblr3zs7I4TML+69Qx1VMTtux/8n3Zyd0FGoXus3U848ePz+P+MXbxjMQXBbhWHOiOGGwQ48QLoP8HsKbM5IdjtA88TRdYnDrQFx22N7FOeKgq7ot2aPWk6qxRldVZp62YnwJuaA02ls0OrdT0HNkk8WCjKFovA0cDi+UucGA+cEG0daSIIXjuI8+H5dOnZam7ti7b5Du3NB9/66t/FpbbDdnjtWHl+cLrt/auj/6C+Ec0jAeUBxFXETtpYM3iOD7A8/UwtyU9oE0w13ZRf13cj4fJ2cd8TBog7wcUQmcMCMg+/BwTB0wDiaTms1ZNcRbDMmKfTUTGw48IHddoKMZsrwN7lRvGsPmFpfAzzwdyZ7C/tyRzjwheDnGK+CS6UrJfRuY5YkcOQFTRdjDujja+hbaVXeAGA/QZ0h2SsET2YKXabyhnGTg6TzyBXArjOPD0eRM2tsxHfMTGQV/xtt0c9tseGiCBeJzCvNiqqz+2MIcxR02mdZ1sAAwWnJR7DeWWvZbitJcEw4lzCe6t3VAuWtsShrDTpG2+LrZTUbmBQV2FFX+1pb69to3vApnJjtsIgPXDuBgH7ojxxmebJ1HPe+sDDo84bLTppJ/MwDZ1nHMScI1dogxxBG1CEe/8FPJx9KcE7nHQxTwC1oifG+2x6OF5xmH7vriwGJaJbWygzzeaQN8AO8bpkhhCzqMTeeWFaSwMiQWq4/xEbN6/n3X0u0xK+QpxvxyvPoJKu6P+k0rp+Kmi7murDJQaOkoO+e3khHKmzS3N3R1wmIh7qbc1brbLsGgvaXxPFDW3tWEdn0RcWwCWw/UVP1zcZ6Wq2DNwuKbcH2PVR07ppzR2xnI6/30MJfPcahlIDNxvsaC4PT2j+43QgPA/bcyLtMxeo30w8AI54Fj7QHx1u+qj1ZrqoIKYP5KKrBEPQBDR55kopfgBxx+EYYoccwAy6Uc5JymQGGfugc/Bc5BZtn+uHQBtg1AT6b8/7mJOubE22jjMD7qWZrS/BXqVUwZug8OGKCDmYTtNoNOxOEmw+2MO7gOb4yLG9oHfjiPu/dJPfljnbw/j2z/5o6+En9WR68xP6Zmmp4SVqwJtvr6pOWmmqD5IpGzK194UMdUfPqZzjk9qj4bIzlpNcxjSZCeR0DndmPKBbh8ITqCONrYVBJhDcr/Ug9X7ODDJ7T7ygFYPx+vzmUnNXV949ll9nleecfWaEBzjsSGCfHcL++Yb4nXkp7U3Fcsrfx+UtbcSYK8shrk+jjw2h1zl9GHlaBngYSILwwiSN8JVcn5c9OJb2l9+9tnnwvLkwnJYrly+EJbH54QSWDymvZhTTfXnB848FJYPIdf9O/+e9rsbf/i/h+W37gqN0kWcrlXUfmv37oTla5eHez0e3ic0sa5qIeetAef69nntu1axVuPe8OGjGscxV/03lgLy+4jizrSj/KlTUj/pzQpLlUhpn5P7Wg+dO6t7+/a3wvIWcsvHJ/CuY0rjzAFegfsWnZau9c5rqrOT7mpYLp5Czgm0zKOPPxKWX3hxJSyXk9of/o1f+ZTjOI5zZ1Ox+tq6sFjPPP9kWP7oRz4UlseOaV9o7Z7G9qCqGOdnNL4nZzWmz2HfAFtcTj/QeN2uqv3vtZQPF5AnT+a4th89ZSNrAT1bJqXYlQPeaHpOY8vL6vNeRe1VQQzcWBOmbG5R8fMOkGUdRxXcIFYa++2ZpOq0s7cVQnzgTFFt9+019aObiJ3FaY2z+K76Zq2HPZeu+titqxfD8ps3dHwKa9NpzosYZ1wnM5n2sdcTwagjxw7wvoD72WOYZ9odXWtjQ0i3r3/nhbD84MNPheUy9oOqO3qW9IJiazKvOZsIct5DYm8e4/3yvUsEpXTAvnwCa8EkcqX3AjqKYujfw5zH+XLE58gZrKknJhVrDy8JnfdCU/PWzRW9i3jg3GNh+aN4d3H5qt6V3bqlcdFD/4zWilohN67fDxwDPvOdV4RXfvniMBeME2OE8USk+zTWi3Vs8jF3Xh7T/9Ti+u6NMt5FYE156576UhEI9kc01J1JIJNAQYv88mI+p/o4lMd8mcLeJrYbtjGVf1FN4gR4bxaf1Fz7S7/+98NyqqCb29hUG66uqXz3nuLm+tr6vp/fWx2O43GgseeBVTo0r/eexaLaMp1WzI9hHHP9kwWSfWlRMf/uvbthudXWXN/D/liAfeIo4vNHw32O+K8BTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUym9yf7YYzJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaT6QOpd0UpHX5S3j8fX3kmLL/2hmyRpnOyWoo5ssBp1GFrBdTRwJFVl5NQeWZKFjtteOUNarCzzMkqKJPUd8uwO87u3XIX34sNZOXVBjKGFsvBAdbLtCSOpXFMBlZdGdhswqrPha1PC/ah1abKtDN2s6qnzJjs5GjPHfN13UEBtkQ1lQPdgpPy1SZp2GTn47DMHsAOdEf3vPm6bNKam7J4SgCNkqN1356NpLusY9OwtiqibvK+zjE5Jhu1B5dkUXf9umz7W7CXD1BnMWJlYMcXRBAT8FujpRKs896LldrfpAaw/Y75sNRnO8I21iECI6G+NL8gy7Qk0GfbFbXZbkVeXR1Y9KVhoed2ZV/oAFWWGJdV18lnHnccx3E2YQXYBg5iZkbfI0Kk2dbYTsJjK5cBtgD2aY22xtMh2KFNJlQ3PvAjWYyhJjx4szmNlQxwFqcOy9b38TVZ3H/tddl5VWDPPz+p786Pw9aX9nuw94vgdYj0OgD11oF1f7cnzEUPKJHEnq0amswp1dWHiJZqtmDRfACChWigNhBICdgRjuU1vtst3dfEpOzWWhiXFTxHu4p790bbpp425R7mB37u4/NOhzaXev4krO98xMM4LOYmJzWeJiZkSXf72jth+fx5IdEW53RMDuM7sRcz+0AguYH6rBtxtNdzRCzufNjrerDyRkftoH3b6ErZNCws0a9asK6utYBhIqopgmHCdWlXndf4LqaB6+jouzzPAFapP/1zvxyWX/r+d8PylUuqY7bb7KTG9ERR5VpNcYhW03NLy47jOM4X/oP/KPzs1JlHwzKHP2cqN4KpQDniP0n0kr4dw9zG8wfB/sdzBmRf6GHcj6JYL90GrdJhfwmrac9TOYJGQn9oloGCRB35Wc0nuSnlPVVgT9rATxJ51wJ+NLaXX/qwxubfBxh0jRqwMsCTjE3Czh34r05dcTcOhGIfOXJz61ZY9lKy43Xjikes1zby1Y17stbc3RD2ZH1N5c17yg0CIAObmCM5F47FVcYwdiaXFPvSh5QXuhXg4mDl20LA8X3dfzqrOJidHs7lddxLZ0s2osmY6jgJn9Ux5BV54FK3t2B32scxKcQpWGOnEsjfA45vIMFczCmwtR/Ljva/YwiINUUeky+oH87NKf8slZCPoA9v72A8AafTQ2Ai7mhiHGsf3E+7R3yS+iFj+f05u93ZHxlIFF8bVs0JH2ivpNori742BsTTbhW5M8YW8VNtWPzCBdjJA4vQQG5MAh9xS9sVxYCTKcWJ8XHZYdfLGqPMe5N5xYNKWbbFRDCmkbcQS9MGJjNOrFZB103BT/h+LK4Cb7yxKrteL9CzFvJ6jl4HCC7gO5tYl3aBMguwzUHL8QlYkedg5V3a0TmTQJBwTrm7prXpSCpOlBI/PwifFDugzO8egC+KHLP/eQJYWUeQSPuhl3gsz0d8EstcvMf2/5y5lItrZjBePRzTfy9W6SbTe9Df+9xPheU//ItXw/KDy5oLu4hLV+8ppykRn8RcFyglFxNBLK6c0sPAHyCnaADhxHX6H39TKIQHjgxt0RO+5h7Qh5wtoGQ4L3MBs1HCviue78wRxe9n5jT3zHSV7xWBuC6MYW/YJS4BiEGUJ4rab+Dau9zXd5l/djGn+pjXPVd14yFmTBZ0z23wSuNY8zeALs14Ov/pw2rzoyeFWzl15nRYXrs+XM+vXvxm+Fmzonlx+ZTwLckq8MYnhbWPZdRu5IPOYO9rFvPrh3Ff6TU9dxVojTj7GdqccZM5ySgCsb/xhvZKlheFNl48fDQsB4eWwzL3BwtF7QN++JHHw3ICeAAX+c30vNAC//A3/tOwfP7mjbD8lRdeDMvXE+pXb1++pOvuzWm3tpSPzSxoPbSLvdsycrCdqsZ5Bhj3uXl999jxU2H50IyOcfv67s1ruu5CnEg0jbNYXPtOXk5jxXOBs5jRmN5FRxnD+A6eEIJh84zyxtq29lrv3NT93LkurNF4TDm8D3RUsqt2ywAvdHJC9fCNrwl3lCgItfPCm8PzLwEX99knhEw699yD+p7CtlPH2vvkKSGbdndUBys3lNP+8JrWPK2mPu9jfyzha88hn9P9nDmnc3rAuQ2AQB5F/e1f+rWwzPViBuOJ+6Ktpp5nt8S9ByE2iCMjLnYc78q6s0LFkDgax7qG8+jpBzRGpif2vhso7nM92cHapIv5uoG9bu6vlpv6bgvo38VptekGYnwfK9w6cK5dIIqJDk9jj8lPaG7rYM+fsbw3IIZJIt5kCnNCt6fnzXGdinurl9RuLu4/m9bxSWDFGmUNpFpd82gyPbyHNFBbfIfXBFqY7yv4PtfHuijJd4ecw4gUj+zIOvj8R9Vov2HkfnESZQc5wrVrb4blak198jOf/oWw/NGP/GRYZt9b39C+Ya2KuIQ8jDXk4h52sYc/d1R5Un5zuI+5sq75oI2+WcF4KgNJFxzgB7JR4oIR7zGIxMLw8Nq6x//rio7/0xs6z/E8ciZca0ah3Dkxi31DvKOI4cIVvBt5e1flN+t4v4+9m3MPKWbNLgkjx3bOY09lcUG/4zh7WmOO7Xb7tvaNV+4MfwOyva19pK0t7ctevXo1LBPNNTureWsaONZCQeM/nVK/KR6AZN/c2g7LdcQILkU4SF3ngD8coNHeaTWZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymd6n7IcxJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTKYPpN4VpdSNy6LvEz8r+8ZOjVbKsMBJyuIqBs+hZle2dnTOnZiQTdo4MA2Nvix+mglYcmdkFdQOZKVDwzhvz/oqlYJVJiyVcgXde6sKS23Y6yRgjZ0sAN8ChynaObdgWbdWk62Pk5J9TzwJG3CglwJYW8YzwD6kcV1avNFm2IWdGyznMr7qyY/JlmgA/EXeVVtVb6mONy7IAs1tqx2mJ2XZVK3L9i/r6R4Oebm959jfsq0JS/7VDVkw1S9eCculbdhYA6fRpF2dI7FN4MIfseaLYiKAYYr4Lo221VmvpnbxUzApTcH+Elbi/M2b6+n4yWlZXk5NqH2v35QN1s0VWdmdOqX2yM/I+srLwqocVrFODJit2aE969EzR8LPVi4Jw7a5Cxs+H7a4wC9UYREY9NTCubysEfs4xo/YdKtcBZKi19WzkhSydEz36XmwloPl3oPLqoO3VoiPkPXouSXVcQqW4932AdaWEQtv3D7QFjT0o3Vjr6867AOrdN8CdhuYj3JVcZjoBqKcYnjuQZ+2irC8w/EdHLNdUuwjgoWIIRD2nI1d9ekWMAXNDkf46Ik4Gg/xJGKrjMDkwsY6jv4QsXeLYI08HE9bQ12rCsxBE+3qEd/QV38ojg37Urup67S7kc6GZyIeRO2YSWouCWBZ6MDWOwm7TtC/nBSd/WEP66EvpYG8KTeAbYL9H531E7AdTHk6fgxW1/Eunhe24URgPfLE02E5k5XV7uqK7HXZVLmsxuWdm7Jx7VZp5anjl0+edRzHcc499JTu3dc5Ijb/+lrElpr9INInIOIueM5Bb3971Li3/3l4FxFs3wjKz8qyuFPVmIgE0gGRNbCgR30RCdJDffV2FdPi4JsEsBh1UUd14GE8zBsu7F+DPYRODDkbc1TXY16qe+zS4hXjpgtMTBPIlhTiThd5abt2Oyw7vnKA7PRxnR9xrVbSHHLngiwyd9eUg7cQV2YwFpF6OHXEgAxQR6CGOnEMcA8IvqNnT+jzgSzQK3f1LO2mnj2OXMiLq33ae30h3lZ9eMgcC3TpRRwsqJoi8dHn/QK7lUU+w9yfcwFtZHtYinmYI/w0kXLOSCuGOYSxK51R5U1M6tkWFpCvtNR2A9g57wIh6vd0/lxWbeZj/BEBlsCaMuKxuk/aPyBagfGS8xNQrbT6TQKVFQfOtIi5OJPCfA1rYHQlZ31T4ynB2IHb7QGtEalvHJMb07iZmZM1fRwTcrWsMZ1GDG0CAbG7ozUa7y2J9UcTNrZ1oOzGMWByGeXqKX53b224vaN8nBUyBQveBNq40VCfCIDH6CG35L10gDjrM0dz1c6Vkp7Vh41yHPb8/QFwWO6I/5sibrS8J2TSAZgkxhzvoPPgc3//87sH4ZaYXtzPHXmdA59j/3Ve9LuY95ljpfRQh08CT5ACIq+xf85kMv2oSjkKTLNZraH+7qeeC8teoNjype/8MCz/q9eUb1WxRt4FehDEdicG9CLxTH2sqbsod4Ch/sbrQsfeRwXWiW3GvkMde55HDmlsXbmp+WBjR3E6NcN8Vfd1e1PHTx9VXvfdb34pLD9cOhOWjz+qNRRTfOIjZiY1591Y0d5iMNBzE5foYL1dHNPaMXC0FkwPVN9PLGl/9S8uCfHSczkX6Vrz47KDH8up/ROYC+cnld8Ge2vuK6/+IPys09datHj0gbA8m1f8ClAJfSCABlhnbCPPbKD+fKxn/peS0KKryKmXsSd9bE5z8wngp75zRfn4P3VGT6t3hKT69vdVv58FcrIwIbv/fl97oS4wvElg3V3kNwEQK8SxpJEPPXZO/fmVCxfDMt9BVIH2XCsNc8etXeVsq7vAR7TU73zkjUSYzswIlXXkiPY5HzorhNR0UX3/zo7yvZUrGseF4+pvG0AOuy0hF6bnhLvIYE8n7quePnxG/T2FdwixaeGnYl/9XlieC3Tdt2aFJpqZVa5bu6i6jM1rjDYxzvJpPWMXOJCxvI7593/x02H5yb1YsnBd+WH/Ve35DM5pzdxqIQtHfkhc6qFDeu7ZKcW7DvamuojzxOT5yPfb+HwXa6c61kvt9wF8+XepAtDU7ZbiVbOqvtdPAH2NXHAGKOsjh4WQKxR+Oiwn8T4ym8UC/gCUrQMMfB/72j0grNut4XzZqOvvm9tav+wCLXJkSXiSXWDWO9gcLAF91cY+6umjeqar68JDcT1cwVqQc3MBaNwU4hpRf0TeEyvINWW7q7m51VUfy+L9ZQf5QeCwzvS8x49oTK83FRMnMNbzQF1tbGl8VfG8s3ND9NnhOX3v7m3F8yaQiF20WXTvVH3Ix3qe70CC/elJEUX2V1F/HHHR0TfaYzHythRLqFpFcf3t82+E5elJYeh+4kMfCcuzs5pnltD/s8CjRVBKkXrhPpk+7aBvn33s2bDcqw/zoNQl4RGr6zfD8r11zZfTGcyneEWfxzpyPKc8aUvhyOk7+jztqV9tVHRf14E64hNdxLW4N5XdBopbtxzZk0gjNk1hbl7FS7RuWve2UlIc2nr5+2H5F9c1RpYWNff7Lvs/7gcoo/Fxza9EGW3txby7d/U+9/ZtlVfXgGBawTEryg8zwH1OTAC3hFyFKKVcDjka8NwN7PW47v4jcBBBI+PlzAEa8d0dk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPp/cl+GGMymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lk+kDqXVFKpYbss47OyrLnp3/qmbD8vZdkjRO4sAgbwOJqW9ZYGV/2OXNZ2eSMJ2STExvI1q4C+3q4BDpxR9ZME7ByDPZs5ft92evUYKntNmVDVEzrOhNF2Q4SH7BSkq3bFuwpu7DidNO6x/S46ikGa14ftkh90jHisvjpwOa531BdegPYycGqmHbxiTis4uCt2uwJV1IIdJ7dK7J12l3VtWhLnof9YwKWdvWG2rDdlHVcqj+8n2xcf2+4sM3qE2Og61dgoxeH7T3Lg5as2QLYCLqwn/OJOEE9BRFkyQGW6iNudUb72zj6YSwHzy/UewBLPKJZMrDXXJyTHeGlK7JPvXhNNlhHD98Ky1OzshilTafj4h4C9bf7rtbzR2TBtXFDtlrXr26E5VxS7TU5LtuwXE7P5CWBRwCaIgWr2DpiVgf2sLUm0Bfoe0lYqXku7fSAzUDfyOAeHj4sZNJuXe0zCdRKFZgbKl0ARmFAC07Y/iXxOazOuj09Y7ul+t4Fhuze6tACljgkWlESFVWFXW4f9+JF7AJ1K8TlpBCUaVk4wOCqwDovFsHx6KRN2Ic2UB5FDRDHAtDLaK/vRdoLsZzW8HSGx/xAVBMxVLSJe/vCpbCcoLXlYH/r66eeGtoO3oLV8fW7QOJlMG/1iASCtV+aCCn2WRW7wGAEiLVpIBGbPSJpcBoivVw+t45PxFROwTafdVaBzTgoCpH+nMrJim9+QZaPE9OyMH3lB3+O62qMbAADuLaq/CCWhKUyYlKnu4fOQUwmDi0yPbHt6ekZ6RP7ftUZ4A8RolwsYpS57/FuBCuI2NQb7bGYSGsecBHrOjXZz3Zge+vDetJDruNnNOcQvdQEYqMNFKSH/kzUZRDousTJ5SY01/b2POBdxMsY7Pa7wHQ22hgriC/ZFuxvYeHe7emYpMP6kKenn9fz1e/IPt/zVDeDhCw0g5rmlUxXMaMZ170dlrutMwb8T7tPvBdQQ4ibSaCGtlr6Q4s5dlv1GocF9cSYbDfZ5t26rMZ74IG01lYdx3EcH3lrBnHNT6tPxFB/PvCqdU25DkihTiGu4xPIZwLgdWjRHACN18cxLub9JLBawWC0WUrdHj2IaSWOdQqebXJK+VMZaJ9yBe0IlN8A7ATmIC4sov0Y11zqP4nEuy513wW9CgQEYrYXmcN0DO1ePbTdLFC0dzfUgZroQIzZU1Oygq/Cst4JgPAFQq0wpvjy6GOymie6aHtTeb0T0+cdWLGvwwK30dC1Jia0Vid3mMx7AAAgAElEQVStpgGUUibDOAh8Jo5Jwqa3s7emGaCN52CjS9RtqaLxnOB63yMmTffVAq6xgbhN23AiUtOw2He5FsSczSSYuNeRFPuzd0CZHY7HM18ArjKKWOLxuG7sPVw3gl7aB88UOTa2/7H+Adf39n+mCEoJsePE47JwPntEfeB7FxSDRntnwDTq+t2vvxiWb20rjgXouJ996sGwXADOdRx7lPU2MOfo822uR2O0R1eM6iOP9zG+uA+wg3XTZmV4rU89JezL116Ulf56VffC9b0zULm0q/0d39HYyuRPheVDwLpUdrRP/GZVef3ttzUnfSGvfLULbE0BNvhx5BudDrB7xCdhbyiJfcY08DeVHeUkM/OaXz/3hFBGV+8KtXN9S21bxLz7GLAYPuq7C3wKEdb9zrAdPOQsr77+Zlj2ZtQmc08LLRDcWQ3LPWC728dVx9/xNI9vohNt416SQCYN5rTP99aK2mduejksv3BbOKk/x5w6iiil//AXvxCW/48v/suwPDGmevnYMz8RlmPILTnjc5+c+ScRmw7yGgdrq8g+B8ZiIqE+k8P+xH207xjy0jYQaNx3S2ItOg4MwaFD2oN99JGzYXl6Uv26jjypVgHmtKLnWFkTrmFjQ5/nD6mPLQDZmUH8YoL21DndQ7Op/HDg67mrOzpPNqP7ObegtekLl9Qnd2uKB+VAefjp47pWYV5rjsuvCFP35AOKE08ffzgsx84PY0+lqXjXPqWcoYNx5mAvYoxrO1AZuZsSw7o0hfwzSRQx8qkecs4OUDExYHtd7K86eezRj6Aee1wIc+b6fayt+kClNrDwbjTQHohdOxuKx+Wy9uYqJcXmalVxneuXOs7fwx5MB0jCEKuE/cmdHZ37wmUh79LYUz00rzmgiXc5SeDst9F/Hy+qj48BG0JsUx0ItTnMfwVgSeIpfZfr8whqtq1yva5xsLOra3Hf4tgRrdFa7f37JOPQh594LCx/8w3lBONYs2K71OlhD7laAWpxalg/QV/1xF1L7lUThx7ZY0Y/8xE3Izj7yN7z/t+lImRmd/+9g1HX/js3jnPtyqth+eIl9e0nnvpcWD50SFgl5pNs32wWjHLqgPpyI3vWEtfyT+/N0x4wae+8jjm0r3eNyYI+n6wpXngt9a/HPva8jpnRu853LgjHWbmpPMwPFEda2HctA6mXQp6Qwlq6jh8BjOd0DN9vlLqK5btxoMbaGkPNrp7FBZa4va558QcvfSssLy3+mo6P1L2DMvZDsdfCva303lw3Mz0dfnb8mDCBq2t6n3z7tt4h31tVjrq7q33lmzdv4ni9o0oDwZUGspJzYWTucCKDXUXizt7Dgt4cY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMH0i96z+j28Wv9eqT+vXlwjH94r9wWceX6vqVkjepXx4mEvqlz3pXv3bq7ejXTgtF/Qp/gF8MFvBL2pk8f3WmXzId93T+a9vXHMdxnDL+Nd0Y/jXmdFb/Eu//Ze89g2W5zzO/7p6cTz73nJsvcANwcQEQBEgxg1wwiUmhVonUyrve2rVVtqtc63JJ5fJ+2C1/cFmusku1tVqVvFKV5KWkVaBWFEVJoASQSzAAIHK4uDmePDlPz7Q/nHP6+TUxA4IK5gj7Pl/wYm6fDv/w/kPPPD/+krrZ0S+E1uv4RR+/7pvT8Rl8O9hL4ptJ+MI4f32awjevcOvOyMO3g1EdaZyzP1I9FGL6FpkXV9kk4Bbi4NvKKVxsdFXHd3Z0rZmivtnnBvjWpaNvZvqBvjUbwy+FU0X8GnTve4fxhr45msOvs7w8flG/rG9uz8Bh4+VX9S2/iHNE5Ntf+pjOHvwFfBy/NIscH/n6KM+Dep5Goa2O8I1jD046TgbfpEWbZ9kl0G4PLOlbyUn8iq9S0zeIX35NvwY5dGgljE/m0fZQrw763ai127+zBR174JjO0cYvjVj8CbYZfKs3BockB78UTeJXKiXkiBjaQxK//k6n8atw/Kqjg18qD/HN1xryAcsmi3s7Oa9vU9K5oAs3Fn6b1oeTEn9Bwmfs+LqWj1+rDgb4ZQd+ab29rbi3Vw/8FnWnp/ZBByten84lPL43gHOIj2M8uk3p+TJ0ksFz57OIc8pl7Ot81mkUnTw4Vg35CyE8v4dfZnkef/XD/oo2gL7uTnD4OIZv53pDtdvyFTnJbNR0Pw/O7v5yoIpvTsfW4bgypNMMngl10UOuwY/KHBhjOAHySBzPncC3pbtIyIW87qfSVF9JIn/n4NYwW1D/yNJ1AtcN+GtA/BSh19dzzeObzvzm9PIB/RriQ//gg2H8wlNfD+PtHfyKYVXnKS3qW+YPvuu9YXzn6Qccx/ku5xY08eFI98tfOiSRCyLf7nbGi5/zVzfRH4PTwWPCmfiD+dgbOy38oNWDE4oT8Jm98Z/zj9GfUviVbhKuYIGvPN0qq5/1cNkR5luZvHJasw6HmbTGyOLy7i96EgXNgXot/PrgttwWkymNVT6cKWp19dchft2Uxrfq6RzYxa+RBj1da4hzxlLKHU5Ov3Dy+jo+hfx956z+dqEAtyJ+Ox8/RaFrFA2T+pg0l28oXgxU9jv41UHnltxekgXN55cOyfkpldJ4XMHfjvq7OaaYxq+bOP7BiQA/+o24ldQbyE1x/nJPdRXAuWAIByIaGnCc4y8UMkiuSbiOtHrT7hiDSRzaAH8NPUJ7o5NjEmVXmvBLxy6cTWL4ZU0c8w7mzzh/rYNf4zoOHFj2ciB/EUfHCp/OMKi8Zpu/Vod7IX7hEhvpmDtW1derWB918Ewry/ql3+K85ubtFuaKyNmZtPLUg287F8bHDqnvNurquwF+UhTAvWkLv7Kki18GLlpz+LUQf6FZa6gsR2jFQ0wK2jg+VtWvhPbdCefxy2YPg88m7quK6+Sz+FUs5l89rD1S2DdYWdGag7++zOVUV03M/elelECd81fisRjb0xSKTiv8FTsT0Jtxkokcj/NHnGEmfM7r0iUGexsRF5j9POFNuMdJ98V5TMSRcfw8mve7eEbjxyc/pV/VP3/l1TCud/l7SpPp+9MLN/TrSe4/Pf6i5luX1pTr5uGgl8UaoJDUWFFtKh+2Is5zOr4Ed8QAbl4+HJpLmF/eqGpSW+ns5uyf/rAcSRw41nzl+UthvLWle8+klHdjHsYtjA3zSxrfO139Kv3r33k6jEeexr9t/Ir90u0NfI5xhfsWGG96fbiH0iETa644JqmDhn793+xz/1P339jR+JDJaCw6uKB6+8S502H8wBm5aQxR/3SG9AfYa9m7/wTqvoF5wtqWyiy2rPHMGyixJQLt6TL3+r6u38Z6+MtX4cqzqpxYXNI9fO2ajh/UdO8Xa2oX7zqmfYlp1E04Nh2Ey8nXXpJ7SLmDuSXGDTp2JuHM4UXGUTj/Ym7ioX1yf6c4o7nPI488EsaDPlych68ffwL8xp9r+gT2O9Jw55ufV51m0Wa5N9Vsq9+sHpIFaA5z58FI97VzUMenC5pjHTmsZ71+7WoYZ+Ae05nV/cThHBlL6t423qX9F7pILq1iPrej90mnPyMnpQfhRrK0qFziwoWptHAsjB2861o6oD6VuPf+vZvUoQO6OKPs17eUFzYuKrcXcrp+Cu97RvjbLuqb7vAj5AUfjhzxhMqyXFOb5v5ttwM3mynUb//6vwnjVnO8G0ynA0oDyohuvJE9WJYR1p1x7MfyFdBMSXXdQ47l3lsK+/yFvTUDCQrVqu63j/rKBLrmCbjmX7x0Vc+EfYVbZbXBdg+OJ0PdVz6pfn/vEeWOFbxPu9xU2/j6db2TdV3kb8wB+mxv2AceDriWBnUgr7GlTScluJ9yrzqHPaluW/04lZbzL9ejMbjezS1oLdvbc2dKcI1NRy+MbT5d9CJLDOTwiGOMjuFe/ESXGNIFJuzNRty8p9x3ks70/khj+5Pf/koYt9o65gPv11iV4n4pnjMPJ5dCAUSYCSSCSIHhczqkNxpqP1vbu99JGMA9ZH5F/Wz50LEw5pxwERedK6ktfe5zPxzGZ8/J5ejC+VfC+Jf+j1/WLcbloBPAgXpuhHdf2Pfd3tIxGcy7B3CTK3fUhyrY8xhs6fsXAfa+3CwGJjT0AfLgn//Vn4Txxx6R00+pyO9CjF/jjriPFzlm91ppkDs49yiVNOYdPqR+Xq1qjFxb07ro5m3lqfV1uspobNve1rx3FCETjL31SI+LOuIkXnfsd8scY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMb0nZF2NMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTG9JvaFPfh/WWFd2XgjjmQVZ2R08Iiuy/g3Z/RSLsstcySuOd2S302/IDqfRl9VR35MJTgLWdytJWOINZAO03ZCdXnG0a5PjebL4udWRRdm1uuyJ6g1YWQIHkcrCWh2uzbTkog2eByukFKyNFoAIcmHr1oU9uuPq+BEsfgppfd6HfSGtWANYzcP1zJlzhYPoX1E5NNZh7QhLPy/iLARLLdjCNQawzIbdGhz9nM7eeXK0M27TRh33DlxOfEblV+nqOj49tIg9wj0SwUMkRYQf4Yy3oHeB1/H7g7HHTItcWGMT5RL01IZdWO45aJPs5h4sBWdn1XdTwBwM0JguXlXfWnlJ9rkL87Lxmz8ghEiATjLcsziLw5L94J0nw7gHLNHmmnJHDBbcLqwhieohKmtIK0B816/XI0ZIZdaHJWO3p+s66KMOLIFbbR3fQzuJoT3PkNAFRE6f9v+w7sPtRCxaY3HV54C4lYDWirqHKvAeO5Umjt/94wiOjAgg4Ga6qO8EUBK0okwlx/fjDlBRflPnz8PGeYhO2oJ9rweLVlr5ETE0jaJdKXNkBH0DO8YRcAxxj3a8QHp5tDtWGdGyMQGb7M9+7h+H8fmXhVH4v//3fx3GwVD9q7K+2857sB3MYnyKw5q+i4YXkEOHOI62TEvmfg84A7YZoCqIFCN+qov+StTROx+8P4zLt2RxP5PW/dRaelaiG+dKsnDcRv84eFCWi7PzQljQIjlbkJ3w5nXZ+L3ng7JcvOv+B3U/sCs+fPhEGKf27AbZxmm/zPlDPA6bXtQ9UR9sW/QR5PERHNAEr0FaNEdQTTz/aLoxAuwrTN9E8A27yoH9ptpJAhavxBExv3opzuFUZwGwHUR0ubB2jSX0eR15Or6HBiukNcZkF2U32W4Be+TLpr6D+XijTctb1W+6iDGmA3wgEE9tzIGHQ9V1DvjT0eBKGCeAbCmUdJ6VWd1POqV7aDWQYzDXjcHSfQBr+htbyoNzWd0z0pNTx7NUuyrLwbb6dA922zNzsvsd1WTZuZTdtfKcwbl9WMRm0rrfTEH3WK2rXJPAB+bisHTmnMTRBRIe6mqEfg+MSID2SnzLCDm/72MxMpViDkHux+ftlqyXm7Avp411DhbwzEt1T8cTl0eb1FYHuD9YtyeBzvJwb/tzE64paE1PhBZtmGnV3EH/rwEPOlvQ9dO4l9mi1mQ1tL18QevbDOyi43EgocD3Wjmg8Ynr7T5sdKNoGRVUo6a+kgcKtY+5yhBzadZDCvO2DOqqg7LPA1mUQg6tA323b/XP+uvCzr+BtkK75BYQGinMuTI5lcGxI8qnLLM6ct8NINZ2trUOSCBP5YAg6bQ1dnT70z0uOrAjj2CHIggkxEQvTcQnvQnE0cTzu+OPZ+XvD+AT8Unj23IknmRmzs0btOsEML+PfE5r0yef1Hzvj7+qMbg/nODbbDJNELECnIv3esDjVGQxfvqu42GcxrjUxdqqjFzrIAfHhpqTfepB2cFv1ZUzX74oC3gPe2Y57LUuL+7u8b78kpAgcazV7ljW+uzkonLkY089H8aNmvaLZnMHw3hxSftFj3/p8TD+0ref0fWXj+laq1qrlYCZvHJF+btSVm4OAu1ZERPhcH8wAEozpriH/dgB5mp9V2X8DaAwzq5qnnn3SeGTFrG2z6aQRIFXbAHbxD2snY1dlOqVixfCz67cEuooB3SVz/2BnNafLi3wkbOSyH3EdI2yWifXgbmpVHStVezj+VhHFYG7GAJ9Mo36r//5z///dq0IbgP1UQAq9Bd/8RfD+NAhtXP+7X7+4LyUeyiTkcjYp+MeJtfDaHcNoBtW5jVHXcqpLW9gvbV+63oYJ5Jqn92aPn/+G8pTESww9hyJfSB+agPtvFZVX1ld13puu6m8+cC994TxmXPCKh1c1vuQyo7G9YUScmigfEac7n4ZJuLj97J62F+9euVqGN8ENqNYwFq0qzltMqsyrrdUrrd3hBtNjTQvHQzVbipllUcDeWR5QX23js8/+9mfcaZNLzwrdB73TpNAchCZQVRHBiijIfa1+9g7Jp43jf0wtvlsTjmN+93dnvKYG8Gp7Y5121XVbwX7DiOMkZtA3j36l3+FZ8L6EuN7pa2/3d5SGz9zVOvCh+4VLvrQ0WNh7CTVln71Sy+HcaejMTgNRKOLdw4jIJ+4x0WUErcBR1gUpDBuEGXbRHtuN9WGe1svhfHtq7qfg29/IIxPnLgjjI+f0Jj6yku77SXmqC692LNhPEC+494m0T2sY75Piux5Drmn6vwXIc5F6xXl7+88oz66uCD04H33vV1/zL1jLI/SGbXJUlFt2OP+lj9+PcV+zzpod5Wzr12/6ThOFLdWQK6dmdU1ifTjnvHRI5qXrmCc4J7LEHPqE3fq+HpLY8+Nm2pvtZbyQWtD42If7w55D9Ht+Qnr2klrXP4tTsT++vJr6nNPP/utMH7k4U+MPSfvh2jrEXIG31eNOwf/PR7XXhCRWkuLKu8TJ/S+ZHtH+eLKFe1DP/Psd8K4UlVu9Ty+62aOG39vE+dLkDnGmEwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMpnekrIvxphMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZ3pJ6Y5SSL+ufrYrs3dYzsgc6cfhYGF+78UoYexlZGmVg0ZnCd3E6VVn3Xd++GsZzC8K0HIzJDslvyb6s2oOdOqz4zu/s2u9twGKPdvFD2hvCLonWhMQk9WDJFYxo6wtrnjQwGLBN78Mu/gBs+zdasBwD7iIBG/7qQJ8PHZ0z7uo+55Iqp0VfNoyDDdnDjeRo5qSSOk8bCJ5aR7ZEMVjfd1GuXSBTBm3gC2CZNNyr5xFs6keBbKiqeI6tgc7XbOsmb1RlNTiBABFRBC0VwT7gj1FXAbADPng2g850o5Rojx6jBSqsA2PAugSJ8TgWD22sNCNrxiQQSz7szfKwId/ZlDXjC8+/FsaHq+prBVi6Z/YQIsV52VQm87DuLaqdzsOecgTb9ADW7rSwHMJSjTaMHqy6AlgsErMxmoAQ6cDG3RmqPNqwISUqxkU8A/RZq0nEma6VAiLDhy2ZC5vOPPgRxA6NRuPtT4kAIF5qv9wijme4ZqOjc1SaijPA32QRDwaKMxGbYKDgcCn2yx3gBXrIxakM7h0VRNTBNIqWnvSsI14h5hHBoOchaqyDNpyDraobsayD5SXsBXM5tfOjx2Ub67saZxaX0Y/2LD57QADcd06WlZm4Pn/6OdnXEf1EO9kYrfddIrrGt8d4Ss93+uSxMH71AvBsB2QD+6FHPhLGn/6U0EVf+PVfCuN8DNgx1MPZhx4J41ZlLYzb/au6hzOy6HRc1o8+Xl7VffZhVXr3294Zxve9XbGHeovg/vYRShGrQzAAI9aI9DGkNeH47zBHbAFJQJowLroRO2aec/xgG5vyvpjMELuiz32yMUkDg9dngPFk0MV8C/PeASxGXdj3xoHFCrrKb7TNT2V1fBf5tlHfnePEMhpP55dln59dFKq0XdcxbaDAWKfFksZRWjsPfV0/VcB41gEuBeXULmsemMzonDOLmmfGfdngJ4ayvOzS2p+2nGhiROrUe2pXnb4OOnUIc+mUruX6uofehqzyHR/1U7upYzo3wvjggp5xrrRbPnD6ddLq2k4mg1wAHEmtrvpezNIGFWi8xHiL5N5A56FNt4/zgzYTscEfYc0RuNP9O4YYnoe4ygHaWA84sG1YpQ+IqKTdMbCFyTjbjOqgzbUJ5q4pWD4nwXzlOffH7GieG2+1SqwS83GjhbUMMD8zec0TOIfMAjNZR17gHP/Wmto4EXzLS8L+nbvrzjDeWNOanGWJInNyRKJhnt7G+quyrjV2Ah0jCdQq+7qLWR/tymdhYxypf2Iy94o57nCuhPpGp8gDP5CDRTMxSfw8k9L97sCW/PqNW2Fcwzw9i/lXsaRcw3GkXNceSBfjwlSK7XkS3iiCTJqEPeI5ve/9eXxCPOla4zBPk9BPzH8TEGET8UmR3DnebvnAGa1T/5tfEL6zUnsyjL/2nNa6A8Mqmd6EoihT2vQDW4D53JV1zcOO5oHyZNOOIzdirpYFjv0Dp4Tau76hdltb0zHNru6nndQ9zO3l+zzm18vA0u50laeLPZ0jNwLmDqiCgc9cq36WS8tmnbjMTE3zt2pWY8ZaSsf7RCMNNIZtbGr9OgS6iPtBzOs9WLFnsxhn8CzJtNbVX7uqsTbpXw3j2ZyOWTml+XxlXfPSyrbqPF2cD2MPc55mbXecqQJ32ABm+Imvfl33mFedfPzTssa/44Su72HN80OOnvtxIALWEF+7rTXztU2NnctzqrcbmLfkSmqL528IbzWNiqwL/w70Zmz6eQ9V7J0yT2TxvmD/+O1t5QWuMyP7nxgXibDk5wkgZiJ7icQyz6vfs/3ksvp8YRZon7rWz9evq+8u5ZWbLr12O4wd7CFulVUGRWA968B1lUrq99xncTA3Lu9orXzxNSHgHMw5e3jvMUL+4Ho6cF7/HiHge6DI+mz8/nQ2r/kv3zm5GZUZXycxleXjKuPmDtaafeWD8obKcg74pCh+Y7rXi1nsYfI9EvEdXMu4/LzHPfzxdYBtBaeJNsZ9zEBNxinNKr9t3RTGbhGo9eLcbl69uSbcTC+Cj8NYj/lnE/kyjf7qYEy6UlUjeOy81sbL8yqnWeyjdkca3599Tvf7navKEy7GsFiAPXaUGdsMMUkjbkUSzRdT3/Vc5hIgCbE+mp9V3/3cT/1oGKewXlxe0lh4cEXlzf3y9N77iA2sjYc+85fKZoj7jU3Yw07G+RyT9kKJE/6b4HOnm8lUwTj06ouaX1y9obJ+//t/MoyXltRX3Al7x0QuM39zf2cAXBfxO7HI+yC8Y8bYubW5Ow9j1ZUOKO/Ozykvrt3Wup9774dWdEy+qNjHO8hKWXsi5ZrK6fqacvCpu7VefPTRvwjjPvam2KGCYHx7cCesZblvH0x4Mc6PWSedjnLAXzz2pTB+37s/HMZEUgfIExwXWSf7qDJ3wlI9YFfxuN4Ghg3fm4gntOdCjLiL/re2rnl3u61xfDgBVcsy4N7pm+mJ0z1ymkwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMf03ZF2NMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTG9JvSFKKYAtdbcl+yEiIPIzsq9KFWVNlYZt0EZZyKQtWHfOZGHbNdQ5lxKyksvBYq7Wke/Zla5s3Ks1xU1/16Y+iXM3YJcWc3XuVAa292nYOxHBAgzUMIDtE0rOTel42glV2rL5qsHOiGY+RC8FSZVNApZDh3KrYTzvHNH9VGR/1NrR3w5Rb4MhbMZhD9Vty/6tW9ExIzy7G0EQ6cH6XZVDF22hsmcrv52i/SvsYmFH2GwprpcVlzeEUprg0PVdllFSLGD56XOYdzs+LEn9jspj5E+42JSoA1xDgo0M+B+POIM0nnqClXaxJFvHQkF1NgNL2DzQArS2fOHli7qFrmxsz8LevVTcxal5sEyknVimKHu1fldt0EcbJBIkQTQLnbTRL1Ow/vVglUemQ2Vblug9tOVggLaHvthoo52gzaTRP5J5XTdGPAXafBv1s9EABgZN7+CS6oQoM7gSO3HUIe2KR7Qg3zvnLO5rgLIfoFxxi04W+Y6O57QoI4ap1sJYAKv+PDAiQ+Cwai21oSJt2FBXRPBMo4ig8Wk1R8s/2ruh3D14zyUTtK/T+YfD8Ri0CGUH1yoUZEP3Iz/x2TC+fUEW8OsXn3Mcx3HKTdXXHMaAB+4Xiu/CVdknpurql4tzygspIEFqbY3vSbTBQkZ1OjsvLMo/+x9+IYx/5d/+chifPXdfGH/q0/8wjA8AsXT2biGQ6ptXw7gz0HXf+V5hmK68+K0wHrRkg7iwIFxNxIoY5b108HAYn37bO8L40DHZVEedDzkG0yJyt6wm2TjHgY9gffMcbBM8noqi41T2LkZJYjkCWErSNpUWsFFb4elTH/kkBdxGAmgMBzbhQ6BcBh3le48Jlv0baKKIgyVyVBLIOdcnkhPYOPxpew+30sW9x4FpyqKvOLdkwx44svRsNtUv01m1XxBsnOKMrtoE7qXaVL3PzcKaF7m8gzxRwnOkgRkZAkcUdGW5ns4wJ+qYXl/nubmtclqd0/F52PVXA80Pkj1N4peLwOUA1cn+NTurcy4uoQ3vzQNamPPC8dVJYB2wuaObn0nr+DhQI2w3xB55sKyPw7p8FEfOBw4hASwcvWGDAKjCmMbyaRTxMq2m6os5h3bwOzuK88Dg1GDr6waYbwFP2AHGpNMlOgi4JdjYerHxc4r9T1Pof7RHj9hMj8bnQj53G/eSYr33iB+SUknip/S3tPJNYD118g7hD2eLGo+rsLKv1DQeJ1AeOczrg4Hup4dyysD6PpNVX+xj/dHDuOSjHnJ55V/a9zaaShQ9WPfH9uYKI3RA2vUuLchSO4/7ygKfNAQ+dgg8b3VLbWh7R/sDxG4VMV4cXJUtOa236w2NEbNzsvuu1LCpMI2KjV/zRZiyk1BH7CoRNNJ4lHQ0JsLJHR9H7P7HIJ8m/t0E3FnEG3kSEu17xzHghM+8/1gY/4t/hbP/q6fC+KvfwTpyyvcPTFoG70kAACAASURBVD9IjW8bREaMgASoNpVzFhP4W6yRM9iATKfU5k8Dd0M84AzW5oeB3njhltZ6WYyB8zO7ezen7zwRfsZ9k7ef057kzkAW56OW7v2OVc0VYxhLinOa384eVN4dBkQa6V42y8rf39zUfLhf1ziXcXTdXh97rRFPd42pecyZTx5TmRElwX2IMuYkC6sag92ukBe/87jW2+2B7uHUUknnKWvcSGR1/yUgtMt741UFqL96V/fequuaf/InfxrGFy4JIfUv/uf/MYwPHVAZn8B8agnlcb2htcWmj/GVyJ4jWjPP1lXeRA2ks9M9R30ziu65jO+7bwaZ9GZElNGNG0IQxYH7XF5edhzHcRYX1U5nZmbGHpuK7L3rHok24fGXLgllfeuWcBNLRSBHkEe493xgWf177br+9sAVobjuxjuQ09wLndfa7tU59Y/cHcfCeGtH7YrYFZb8NtYQXeTNf/m//mvcs/6CKJUIZj4ynxiDSkI76GM/k7iGD33042F85m0PhfHaunJsOq3+cfSQ8uDXHv9qGG9uKd+NsCa/dP7lMG71lBvmSyo/f0C0jDPVOnX32TB+6huPhTG3YkZD5ahMXvPvak1lmkfOmZsBDgWIvGpNY9ShmYNhvHJY49vhO06F8a0br4VxCeNVsbBb1vmCxrND2jp1GsAqNTA+cc/uzgWgr7HWX6upj37haeXyka828KH3PxjG7z/x9jC+XVO9N7H26qOdZNj241pvcz+b2FvuCRIZzfbfBwong32UOPZUDx3SO8tcSfXD9fQQ9exjHcf92NVDu/uxVy9f1jmQU9zIvonuhWv/BOY4CTQ0z3sza4Xv/fHfV126+GIYf+MbQgEFI1XqIx8WqjGTwjjvjl+LxfF+o1TSeJXAOquL/VjWdWS7JgjGxoO992MxtOsY0dtogy7qN4P9g+OHNTfifketofleuaI52y1gJuPYv3vkI58M4ye+KRRVv8t9PT6TM1ZRFBDeTfKgCeUdxbjxYx30nee+HcZXrirH3XXqHP4UfSqCuANiacz987MISYm3xa1YrOeHE9BPZcz9u13lVqIhI99ZmICiCsZ+OlnT/QbSZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWT6a8q+GGMymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkekvqDVFKcdjo0EW625ftFa3EC7OyImrBWrZfhb97Q8cvnpadV5yICVBgKkPZkb1ava3jYXneBvak1979PNHTDc/BaqkJK0nykEawCksSVQCrLhzijFxY7ANJEAMXZTTUMxFdkszoRIW07K0XM7LEO5GWxdvcQEiHzW3ZUm/D3rMH7Irv67pVWD43a7IiGvYjZke6zyHtx3XP6ZTqKgFMQx92nL09W6xhD+gQ2DAORywbfV5ew3MAEUAECR2SIrZIxCqhaoOe/mcIu+9hBygJfO5FbJqnT72eOkUHdtUebO3isKP3YJvupMj9AkoJKKMzJ2SNe+3aFg5XwR9YVvtMp3XOhTnZ4+ULOmcqv5cPYLXtpXWPuYLOt3VNNqI+npUW9w5tImHrxXMmgGGLp4i8UV232sCL+bLfbKHNlKt1nRPtvQS/QNpo9pHvPOAPEsgfPsqyDevAFp43GClGETt5/A/t62l9OIDFfX8v9tBBiKhKoQ1lZ4icYp8n6k6fE8fT0SUjGAEisGgT3Ed51HCeWFzPkWSdT6FoGeejHoluKBVl0+8CO0Trx1FAZBLsAGETR4tH3x+PyknAMvDHf1wIoksXzoTx539jdxzov6wxtLalNv7KefV55kv2+UNLGt93djQu05M2B5vCOcwHTt91F+K7w/inPvtz+vy0MElLS7Jt9n2MCUP1g+113f+BPbthx3Gcw8c1drbrsuK7+OwTYZyJE27DQURlnwNq4eOf+ckwXliQtSrRD7To84jX2Ru8eCxFS1FaASZc5JHE+D7B8S8Y7wYctWfE+V3Of1AGLk/kTPe4GEO5sK+MMAcaAnEzwDwpUhac8+HxR5gvDvvjsUqsa9oAtzHO8KSpvVzuop/3mmrLyZIsgwsLateNLfXRBhBnNdjoZtNAaGHuVa8p18Zhg5opabwOgETswc6yuqbrxrOaV8zMKzfER1XEKicM2c71MlCrSbV5nMbpBTp/vyY8U8YDAgVTm0xS1+JaZHZeFRRD3VY3dm8ol1V9EGM1GOkczLczwEN5tG4lbhQLhCHXE7B37Q91vwWsA1wcPxjheCBMU4k3YwL6g9OgT6yVxrYK7FAvX5J9KzE4dfTLVlXtbbGA9owxr4V+VijAmhrtlvOhCKpw9Hqr2DRQE33cSxKYnzawpZE8gn7cBC6z0gAqDWMYkYuFvOauqwfU1+k5S8xGIafj+XwNICwWF9VBZmfRuUbKZbTpHWH92u9jvoi1N7ESmTyQTHiWHvJjGTb4Xcxvc0Cd5rK79ZaE/T8t8wvA4dHpeghURhfW5T3gqrpA4I2wvp2f11pldlYogDRygD8gmkt/O1vUfGbacZ+R3zy5jNFxuKiOIIt4mgkYJk4LIr7Xk5BJE+7HG/c5zzfpOSblwvFzF3fib8Bot4wxAftL935YeOBfQH9d/r+eDuMv/6XGqp2G+tm04wxMf/ei7XcGc5R8Cms4HJNNcD9OuTk/d1Tn9JWjctjnKOSVo569ojb57GtCM5SBwaljzT6X0zi6fGwXK1FpKXe/dFm4lHd8RNiJK7c0d73S0hyy2dC5Hzp7Txhvn9d5Ml3dSzatzjJb1DjQwDjqOhinWxif0L0TnvpfCmvsY0satz54RuvL3IrGgW9cAXYP52+3dG8/9tM/E8Y//G7hQH7/134ljP/wW8+G8bmDOv8M8sf1LeI9sC8W7I5vO0BrtLFf2x1gD6Wh8n7hhRfC+EtfFGLpn/zsT4VxZ6Qy2MQWcDqnch0QbQjca6sBW/u2/ngD9XP/fVrD/33Sm0Ej/W3hk6ibN4UGm4Q72tpb9xWwHzHHPVf0+Rz6sDsBA7qMvZLo9dXX+5ibEz8Ud5nL1Gbeib33s+ijB39W+1GZkxpHq88+H8aHHv1KGL9Y1LyxhX3DNpAUiwtaHyeBRBu66BdV9YsE3mmUgGjj3ugQex5JICP3z+gBDoElXOQd2QDYmvU1oX6eekaYkgHK9Sd+TGiShUUhPVpNHXOtor41wPqc8xmkCScbaaLTPfm49+3vDOOnvqk2wPcCHM+wverE2thLyKpfFLB30sb6KIG2mskB64d3IOxHAdp5uSyEYGlxt268GLB/OF8+r/N1sRYtYd1zzxHd4xOXgOMEPncAFB9xUuwHLtpkH+sdd8R9+DB0dmo6Zzan8osB0Tz0JszNMY72OrwH7E9E1nE6fxz5g7lkhD7HfZRkYvyeY3avDPt9vHSILBXQb1F/Xmz8PiqRPpF9XJf78mNvxeG6gYfwrep0976onn36sTB+5eVXwvj4Cc1vzp4lbkeKrqywhkJdzwD3xvc7UZodyhT1x/2JyDuT/T2zgHt9+jvus3APfAG49qUFIJ7wHqWKPav1dc2jicU7fFTj2cGDekcfETHDb6pB4P00X0sQGYZzuniNEWA8C7D/7WCvlejBRx/7UhifulPvZFiGQcA6wfcc9vqLy2tOaPwRADm5StiXb7U1zt1e0zuqq9e0bqlWlSsDXIzrq0gRR7BU35+mfXfHZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWT6a8m+GGMymUwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkekvqDVFKCfj0DGBhVKvL7q5cFAKlXYPVzWghjBtrsvbKF4BJGej8SxlZA3qw79noyqK93pXdTrWu89DKet/kq+HDUmmgey8kaZcLy2SQCvqw6anCVtmjkzARF7AHIr6F1lAerLoWMrJ+O5uT9WTJEc4m4cvuqQKboQ7QKcSS9GCv2W0B09IiNgaWVES/6I4jmBaHmJY+bEthae6OsYynpbyHMuCpSbTaviV7qpEfMV7S8RMcmmkV14Vt/7AGBMKIluqvR1z8fdAQddGBpXu/IhvbGOq0CBtyZ472eHrmLKw5Z2ZksVqvKz5xTLabhYLOeWBxAZ+rrWaysvKM7XcqcthwX7EcsUr6uz6qpVMHYiKpdJVOwdac1q8JIlJw2ZyedVEuuk4uL3vK2xu6VnqgfjM/q3tLw4qvD+t4B/0viLQ38teAjyjIti2f0QOX8jo/kXU9YJ5qHTV0pDani75Tb+8fw/433sstDRRIKkGkj46JM3+hHdDquY8y8HGtAe4rgrSCregwAEIqOb4Op0V9WN4O0AbyebUToiRisMUlmiwBlE2/D1wQqinO+kCFDFHuFC14T52+N4yP3PmA4ziOk3nqpfCzDOyqyxXl9y6ejznVR37JAdU2W1IZNDtqp00gFEtzB8M4BfTZu9/zvjCmJV4szmdFQoCFaRX2oamR7EBTaeWGJMZaH/1vRLwJECDxONE8uoejR2VjHil7zIs4MNG6cd9SkpaQtO6MxcZ/P3lAZCWOYV8cTbALpBUlxQwwiqAKx4+Fo2D8eDwtopXjoEW8F8ork8XxxC3Bm5eojgHLHcg+dzwqhpMTH21jSBwK6jKxN+5FMGmwYSY0a3ZVc8JWVfPuSlljFRGVbCc+7PaJD5xfkn0oc9MQlrNJINHqVdndpzBvm1kVUiw5i0EVc/NqVffQ6el5jy+Pt79s9lRXcV8Wpuk0UHtx2lrrnj3adGKy2agAM7rH/suUYKObpG2y/m4+hzUGECQe0ZCIIzhF2HGzK8ZoKxzDfHzIOTOQebAndmB5PI3qddWG20D7rN8Gvg92qElY1zabWufNJFRf2QRxb2oDC7C9brsqlzLteIk1qis3eJHUGNv7TB/SUpt2wJx3M49Ex2W1gZ2KyiCDNpsEKoO4oDzmw8R4JTw9X7+rfry9A6QQ5iE5nDMDNFEWOE43ULvaruo8Q6A85xeFgOCctt7Qc3Fd0moI28txMY+5QjqtZxmNXo8YzMCCO4Z+MIDNf6upOTvXwJxndjCmZ4DJmp+VjTmxrxwvmzh/gC2SSl3P1x+Mn39NjSZZonO1P6T1MsZ5jEvExUbxSUQyeROOASqOdsfx8evR8DxeZOGBYyc8R0TjUUpBdHY0IaaAj8C688x7hen8n45oHH3gd18O49/+LeHiXnhNeafTn+65lOnvRvefeyCMO23lTkw7nEFH7SSDvNfEXDSRVr6ajQFX2QMOGt11aU57NGcOYX2Je7uIvbcW1lMzi7v7Pm5cY+jcnNr7q5e07/vK+cthfHtH99IEhukwNl2e+OJf6gZy2ttsdnT9y7d0nqOHtUfqDzVWbXXPh3Ec/TiHOcMM0CkFjIXrFZ2ntSO00xZQgsQlcu146rDKtbK1FsbXgarYBhL+8Vc1/wlwniFyzEtAdBfju2PLKqZ7A4xzBWxE64kcZwB0xzNPPhXGG5/6YT1HTnP2beTtJfBJ57JqZzVgOXysYYK26jZfULvoq7lMpSL4XHw+iXLw/SKWgjfBzovHxu9Bcw7Kz/fb4c6O8A7csyDCZJLuv//+MOZexjPPPBPGFy8K/3X/XUfCOIl1IdfbCWwO3bmt9eiZf/5Pw3jxcz8RxjHM91c/+bEwnr0HGId/92thfHNB+2m3K1o3FBcXwzhAOXVbnMNg7I+rI7kYy5sdzBexdov7nNvs/RcYUp8vI9CfPew9HzmsdXutodzOOiSmNZshGl2nf/d9J8P4Ty+rTyfxfCtAS93YUDlls9+77f4gRdxNMoM1C3BgC8tCTG1taf6dTOE9Awosuset589ktaZLoL+4EfQL9j9Suh/2tbmZ3Vx3C3uYaZx75X7tN3712xrbji/p8+ys8qWXwVqjA1QW5gCcXjeaOmca9xDnewl/0n7QeKR4Fv0yQSwN96ewPhgC7cR5Nef4McYRYqvOT0SUj70D7q25Y7paGX0oMpPnGoOoc5f3hbGTKKVI7sU5o/+DqwVjojcaRyb8w5Roa03vBcrYt/jJTyBPz2g/ILqCGo/h9bBnVgQeLZvFfk25huOxZztpDTrmWqyjRHw8HovLzCMH9U6zBPQa98O3NjRnu3ZdOB/m8o+c05jqxoGgdvDSZAJzygVGaNLjTVybRpDCwdiP2f65hT/09D+PfvXPwvhHPvnTYXzkkOYH7qQ2H14A7z0jWGKMobw++nwXWLjNDe31Xr6C9cS65tcRfDnnTXhw4qRYCERCvZk5mjnGmEwmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMpnekrIvxphMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZ3pJ6Q5RSv0ushvxwGg3ZXje7skKqAsfgNWTH6MEablYulM5CXPZK1Yas+DYC2eps1nStdSCFul1Zh9GCeh/5FIO9jk80kg98Rw321imdm3bnIDI5CXzuwg47cGT9RSv9fFKWUXctHAvjs7m3h3G/qWM2G7LB8wLdTxk24OWa4hEQE5mkrNpouE6LtR5wHd26bIxQJI7T13MNgJMJXCJTYKU2IMph934C2ETFYKflwl6pU5dtXHVDiADaSgXjHbqcYDTeCmmI64664y2mInb7OOu0IyOI7+jCUqq8BgzVBux4YbOXQBtw87JMTcBWcnVV9pS0I1taUB+dnVE8M6P+nYX1IREr+6Ub0HYb18wsySaxuKnn2AESg1b2Li1IYe8Zh4VlLGKnp7pOogziJT1HkraKCZVZqSRrP9q6DWFpO6I914CYFEciRgi28/mskmLR073Rzq0OK+JWT+ffwec52MQ3u2oXlb1jXHz3sQkr3EnWfkVYepZgQzxfUFYp4t4TI9jfARfQgC1yBba7Sdio93A/I1gc9jtAnEyhWi3lrnZLeZrWqEQmBcAKdIB3SMAClG2VNnFsbxF8CxJlp6n+UpiRTScd4973gY84jhO13b199YUwvvKabKlHQ4xDrvqZ39MJh2j7tAaOYVycOSj77LvuPadjYO8ZAxqJzxq1GNY9nHy70EtdWOSuHtC1MkBJzCzIOvqe9z4SxsUloZ14P+wXkxz3aHlc3dHYlQeajnllv26Ja4jkEaLmHD437wt/y/EPIc/jB7Qj5fefg7GfTxpTJ6MGpkOjCK5IecYDgsxDbomjXnyUhQ9bR847EjnZ5PI8w6rmqwGtX9kvcPwI9zPcy3sDoEEHXdmXusDKpGBrPrt6KIwr6xth3Gnp3uOwi281gLbp6B7nUNcDIPqCgBg/YJjgzx9L6Dw9YNPSsGgnXax282YYz+SU17NZYP9q6t+DjNpkKaPz5xDTLbOB5yL6szxQeQ9gj1+c3S0fDxyDdhcYI1jHu/AA9YBgjSU4b2R/hXUnsR9IKpk0UDE4fuAjz8Ig300ox8Vjb7hc+4GrDSv/7e3tML6JNsA5UDBQu825ahtFWO3SzjkJhGuxqFzb8PV5gPXGWk99pN3WtdiP96uGuZ7zX2Y/zsE5z42OW6r3bWBOk7DaXShpvpwpAC3Z5BpU9zC/KMxwCzgnB3Osu+86HsYHlrXIjgPphWbrtLGW7qF/HMA4WppV7mkCk9Tb1vyg2VTe8rEuyQCZRLxqA4it3h4WKpXQfNzFGNYD2mOIefQIc5LeADipDterYejkcf1cVvU2wsKXGKYusE1ce99e39Ix/emeo0Z+8wT8XR9YvI01tc+bWDsO0BkWV1R2h0+qXeVXVWcOxrYIf5Ue6hE/9QnH7PfLSO5kPAHfFBF7rDfh8/E4jcmIJaLzlJuXj6mN/9h/r3n3fe+TFfUf/vvnw/jz/1EW0Tt1VIrpLa355WNhfGtdY+E20PPpmPJSzlPeC1LI5bBonytpXnrs8Jkwrm5r77SJvcIzGBM2gFfPetp3ITb+6Wd3ESvHP/rB8LPlRY0Ho6HWwI9td/G5cgfx1XefFi4lfv16GP/xeZVBrann6wOReWBZfe7mmrBHjQHmiiliAjEec66IPZTzW8qDI8zzRhkgebFXdXhF9vuDhuY2v/lHj4fxMxevhjFxjLSMr9SUc7m+4x51fQ9bePiwcu/JBa1pPezXukAP7uA65S3V63ZTY2QqR5QsrrktPEUN6/8iyrW7o3XJcSDCkwfUtr7x4ovONItIhSiYD9gQjH9/s11hnbOYB4Z+SfgGYlpamBtxnryPeOE+LjERnMux3R08qD2OpSWtz65cERoii/kQ96AiexLYgw1c3UMWaMAZ4KuL7393GD8FVNPZe7QHVC5r32Rwnz6/4963hfHqC0+H8S30RaITupjXc61QWFI/TmJ+soj5Sfemyq1Rwz5eDntoe3OOIeaZzHHDIVDqBZXB/ffdF8bnzt2j47H25n5FUNZaJXPuLn0OrDn3LmbnVZ8rq5qzb1bUj2PTvl5saU2RwN4pEbtcc8WBvslE8Njj0eKFGZVLq63xili6Jj5vYS+XGBhOO2N781W+V1vA+4RT82o7bnMTx6j/Z48LwfLpuzW+/vHn/30Yp7E3MJNXWz6C3FGp6d65XvSAg3dclWUMAweRfg4wuR7eZXJq7sTG5x4fiDGOZ8SEN7E/3QUKeNDV/Q8HHNTGY7b33ztub6qv8F64P0J0SgTxhOOTE/IpFSEpRT7/PhF73/PoH6xubAmNWVdKcxrYo+kiF+WAPouUBB6UeyH5vOaCReyTe5h/Rva7Y2wDmM+NWbtFsdbc2+G7Kc7l1If47rLdVjttVjTX2drRfIjt6r779B5/fVvz+t5wwt4AN5ki7xnwTMGEdTL3FjFXDOooM6Z77DdFsU36/Mata2H86GN/Esb/+LM/j1vgO4jXv6fgLfJfPc6p8Q897K2sAZN08fJF3dcNrQ86mNuw0FjPjNPp8VjJDvIO96kmyRxjTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUxvSdkXY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMb0m9oddaqyHbm5QHy/KYLLBeu/1yGHsx2SulYV8Xm5Fl2lJCNkZtWNpcA5KpCXuu9aZi4n+SWVkC9Qay2Bnso32IYoAnGIk5cWAfPCA+iE+KwZLIgyVRCZbopaSsJA8WZN9WTMvKcCV1JIzdocqpP5S1ZrMtu5/tqiymWrDC7Hdp9a77WZrROfNAScy7svdrwDaumdI5Oy3Y5jdhndml1afawgiWSkPEtBjclxdpYrrfbSCAerBDpMWUO4FrwecOJjiaBc7446OnhK3htKOUgGvwYWlW3lK/CTpqS3NAqszC4tFlv4Sl/Pz8bBh7+L5cIScbP9p0xmDrmErpGNrUhz62wBM4QyAugGbKAXnSr+mZugm1WR/Wk8TWxMZY4ztOtH6jHm+qa6KaCkXgp4j8gUV7F3a8tOAlTo3eixF7MeSVFHIP7SLLDfWFzRrs/2EFR3wDrTkHtDHey08+bCPjQK/5PjAiaPu1turKj2CjxpdlMSerxhIwHqwIH9ZySZR3DPipAdr3YMq/r5mB3TLtSpOwNaZlHK1BM7AgjFgp+8jrLu3rJtgEOrRz9cceT504cYfjOI5z+LBwLI2m+tmX/tPvhvHlG/9vGC+uCHe2sqR7r8B6eQfj0/s/9HAY/+iP/3QYn71HdrKRvIs2Nonaw/I4c4/sC8/e/1AY+7Di9FAnR47fEcYHjwg3kUiqrmhRHBXGfo99BxbC88JcTBpP9q1/idSitaMDxCBRaqPR+D7nTcDF0YYxik8aj/WKMG8ieRsVMRGxNB0itnEE++kR5pbuBJtUjqkB5inM/R7y1QgYIY5/I+T+XhcIPpzHQX1398Yxjj1OoHvvtYBgyWjMzc2qrS0eWQ3jzauyl89irO80gGryYYkKBFKAMaNS4fE6JhVnjlMO6KHfxzAep2Y1110+qr6V7Mqu1R3JNrwzAHalpLLMJNGH0OY7Hd1PKsX2jHUAxjqi2Jy9uNPWv/eAD00n0G5G4/Mw88twwHEUbYi5Gjgbh/kO5xkMgV6LE5+ksSOdne6+uH5b7fDmTdmhttrAFqBfFmJEQ+j5E6jrRFzPn8rKgpe5Kwvr6AHWPjJqjVpHE/0XhJawRMjqHmkfHLVqJpJO1+ng+BS6fx5oUyIaYi7bocpjNi+L3wL6dB/ztmPHNGc/c+ZkGBP56wOHO+ghBwxUHqVZnWcW49kAz9KoKze0UZ9s54mCUBs5rBUaDVkUt4GLKu3hQLLAgdLC30W/7SN/0RaXc6IjRzS3yabHIzE4nLWAtazWNRe6tSFk0hbwEUQWpDjXnUahnbS3VV9/+bVLYfx7T8qS/NUysFIoo4Mlld2PvFs4kR/98bNhPHtKa7fv4haHYQQtNwmVtG+fTd7FRHzSJCtz5OzvgmV8778df55g0uc4TQrY2dM/pFz2E3m1k/Pn1cYe/br2P4JJzE7TW0K3N26HcbWiem8AEz+ABXgOmIyZec3zFvMa85aB1/vou+8N444vhMczj/9VGK9f09i8gXnbpS3ZxA+xW/GNbz3hOI7jfOi9QteeO3lnGF99TRjeIxnl4y1X88YF4FuWMhrPagWNN5duPRXGuaxw3iOgeloD7WW1+0JoxJL63IMl/u1NzT2Snu4tg70v7kN0sQ6Ywzz2Yx/+aBh/4P5TYfzK+Qth/OIFYWk4Nx5ijGwAN8j9sRTWoNwD6u9hTK/s6O8+cFRzH5eDGNJaFuNcrqS84wHZ/Ar89rmm5Xq4Ajzp0VXt19eqGsfzS5rjd4AayGONPY0itiCG9pBH2bU6Ggu7o/H7wlwTLQJrto4ySmM/6Piq3hGslzUOFICV4J7AOFQA2wjHjBza/sMPPxzGCwu65unTp8N4bU0z42pVOWh5WeM78TQ+rluc035QUFPZZDA3z80pN737jPpNPIm9LyBi60C+FXD/d7/4bBhfnlEZD7G3Mgkv3hthro51XLKge8gAh3oQe0Dlps7Z3kdmBq/HSDiO43ioJ9bPq6/qvdjv/M7nw5h18plPfSaM2H2ecgAAIABJREFUY8j/LhCp+Vn1vw9++ONh3AFmNAdMyZGjh8O4DvzpNCqFvBRLYP2LYzjnTiRVX4k0UErYO+G7nk5b+ygj4IKIyiXm7uq1q2FM3FIM+XanWtn7d10zi70gF9eZK6iNj7COrwNBlplVe/zUO7RHehcQpi7Wnc2C1jhNvAscoe25eH86Qsz9fMcBrjGCvwEKnGs7ji3Y/64CKcu+wL2v6qbmHsWixuwYxmBiwrgXyfr09lBQwz7Q4bxH9GE3gnVCDERPgu/C+I44srYfj7aPrFNxzKSVxZsgL/1AdYno9ISe/7d++9fCOJtSDv65n/rZMM5NwPFxbyOPMapU1D4B8XcsIrbnyD64+/o97ug7Eu6rq45yWbWvQ0ApJfHucmNN+5PXbmuM3NgUOnNuVnPUO+/UmPofv/ibYewDT/9d/K0wjK74grGfu5ExB+vgyJwE7yC5bEa58jTEKvGd05cf/eMw/uRHfyyMDyzrOwyR9w579TOKvFsf/76+jxyxCQzaxYuaR1++rH2JOvDVbE/cL2fbKgJld+jQIRwPBCv2Jjc3dA+TNN1vIE0mk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMpr+m7IsxJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTKa3pN4QpdSsyMpxmNKhblaf396QrVXah+1OQjZmKdhXNWFBVh/KymeQkh1Tp0P7NFkd9TL6W1orOx5s3/dwKAH8gAPYcrox+g0pngMyZkSLSViAHizIavCO4gkd7+uYVJyWl7L+qTT1rD3ce6UuG8pqU5/HAtkAFVD2bR+W1h1Zom7tyO7Jm5FV6UJRcQo2ZjlYTffyQKmkYXvdks1bp6867450D10glvZ9qmkdH4f9cReoqK21CVbCEcuxCZ9HCBO0pxpvgRbBwAxpvTjePm0aRcu/YV/tfQBrLNorVq/Ivjc7rzaZAS4ogO1fClZ2adg6JmB3OIAnVxplF6PdNcox2O/rsIiPWGNn1R4zB4+G8bCm3EFL0SFwKcQ3xYgZ0tkdN4LfgvUdjonBHiyGPBWHLR+xEh6wbbQCpHUZrUc9tMNMChb+KMsyEHHVlp7Rp2MubBDTRMDhurn069M5UUu02u0BY+Sj37S7+rwKrBKtJV3cVxxl5qSQN2GlmOXYgfJIwcqwDSu/QcQedfo0GKA90BYe5ZhIELugI9iPc7ByZatkOyT6hnVNS+aZedn7xSZYu8b22kwsDtwhxrZ3v+8jYfzs85fD+Gd/7h/pfjN6pu88/a0w/sIffTmMP/dz/yyMz5yR1SDtECO5eUTLxPH2lGxwKYxbA2AiiBisV27q+AzyGp6X1xq9KVzQeKTVxKMjlo/7/2WeVDiaMPZE2wH+YYL16SSMFo8PJpS3F8F0QVPuARqDPXMABMqoh7krnnOIpOoh/xClyTY5gO08sV8e+neMdpJN+lainQO3tJ9LXdgHx9A243lZQ8Yx/6X9dLYkO9B0UbhBF+NWAAxos6t5XaMJNCCeu4GxZ3YW18rAohb3g+m702/B3haWq0snZfMfGykfVF57Uvfpyc576OpaXkzlQ1xq11fZz2Y1F43ULZptEnmr19/9Bz+Aja+j8nBc2vHqAYeYZ3nMZUj/xMpwCCsUdH0fU6EhLL495Lg+kExx+qBO4oZOiW7cuBbGrRb6H/plDmW6VFJZ08qY87kMbHpd5ENaWSdiinMxnTOL+Vka81s//npbdF6feXSAeQkTYxc4n5kZWQPTNrYEi33iF/MY96NYvPHz8QbsxHPAKt15QtgCWgIPYZFL7BfxFE5Mx68c1Lo2hfvc3sQaTX/plIpaTySAYG0DOdpoKCeVy1rj0hp7v05Y3pF1DqrJxxyc+fzEca0b5ooq1ybseCs1XX9jUwjIclX3WMP9tiNoX1j2AnuQBrJrGhW0YOv/rNaCv/IVWQo/VwM2dcJ51tvAvD6q8ywsqKw/tqTxKpkjThXznUn4pDHY0CCCY5qAeOSYOxGZRBwS9wnGY5UmZ9dJx4+3wK4Bgfv1r14N4/NXta6d9v0G09+easAn9TvKM3EP6A+MG7c3ZeP+oQc1Z3rwrPYc2W+OLGr8WQN+J479vvVLsi3fqagdtoDL64+IY9jFyX37q38efvb2A8p5l24oF7SQax3k6TMrsjV/+VXhjdbWVR4jPEfC0zg38oRh2t7W8bW68nciobGnP8Q45+k+G9hrrWHM5k5RCvsTi0Dk3XPubWEcT6qurtxQDiXOwnM1uatgD4tjPLEbI4z3RFvvrwfX6jpfC/vZc2nsWXlAd+R07oN3CqmSwpxhDvPJFYyjg8N3h3Hjymu63xmNeSWgXN/zkBBb/+H3/1MYP/yJH3WmWQ/lgfIoaa6zuCLEzdfOXw3jHuaxzNlLKJefeb+Qzr/3xDNh/A8eUvshqvHcIbWxY0eEpHrl/PkwngOOaB+3xHZE7NHiovZ/iAHl/s8G8AHNpnIQ51vveOc7w7ioonGaZfX1LWDKYnh3cRjrswDvjXLHhV+rt9S/s1m1yZlZlf32Ja0hUl21/z6wlw2gl7ivW5rTPOQAcHSN7XVdF++ZsLXtLM4oZ7QHKp9Ge3f9zy2fXEZ/2MD+QKup+/rzP/tTPRPwETexRioVdb/3nBOacoi92fSM9gVOn3swjF99TX10HvVfbahOuF84jbpxU2UReXcTWRONX4sFEbyKQu6z5IqK63Xs73A/DHO7IdbdEaQ5FiKV6m4/JsIrQ9x2D2MYrrPVBRKkCgx9TXnheEnj+OKM2mkdaJY2ELjlptp1tap6H41ev751nOgeoj8cP+Pn+5Ak9rjyaKurqyt6Fuw3JZPJsZ/Hubbn1B7XZVONkFQjeLTdfNDvNnEs9rhRD9zP9CZglYjUinnj93Qn7a9O3Gud2OWmuy92gOpJLis3u2i3v/XFXw3jAvY2fuzjGvOzGayLiZrF/sQM2jn3uPkH0f35safEvvr4vSMXc8sDCxr3iSElrnkH79DLlXIYV6qay50++0AYLy4JK3jt5tUwDsa/Yo40eHfI9eh4LHd04575jicafwzvIfp6li8edLFLly+G8de/KQTrj3/mc7i316OgIp+hnogUX19TnrpwQePWJeCTanWsjTGmT+qvxIvfceKOMD5+XGskzxuPpmwB7T1J5hhjMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZHpLyr4YYzKZTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWR6S+qNUUplWc4EeWAfgJLw5STnpPuwCV0Bngd2ONf6ssTrtXRMvwFbX1jJjWAdFsB61EvKqms4lOXeoL1ryePSGgo2TnOw28s4sOPJyHoykYAFdk6WfKk4kEkerO9hyd/xVQbbPdkxdToqsxgsfuiWlEvqnL1AVkS0DadFWBzWYbRQ3K7Kmr6Puipk9Fy0K6O9Z3JW99ZIyhKx3oKVfBv2SbiHnr97zz6uOQBq6fY1IS7K67KtmiTa6EWspBjCSiriKhXlLYXRkHZof4/cjJtN9hu1jStXZNO43NOzLSZVp91N2eylVtWnh6nxCCTicfwRLOtdIJbiQB6gf0estfZiF56CLHIX/cwpwmK9JItcoq+GsBv2Jthx089rSJTSaPx3AAOXtl1AgAFXlBwBT4FnGeJ7hSlf52nVZKfoAlWRhGVvpaH63AZKqTsYj04YDYnpGY+iSSMPJffiBG0eUTY+bNR6sIXs9BTf2AaiA2WzybaIv12elY1eKQ9kT0rlR6+4Hr3ykSem23QwivOJA1XQB+KMlnW0p2Sd0o6TMTFJUcd19CPUO3MdsYHjSjJqQQokwYmTYfzf/vx/F8bHjx8LY443R4+fCuP73vYefX5U4yj7E219iRSi/WUMeBP2bzeCFNI9J5HjUvNqbz6QaxwXmado1TgkJixilwmbVdx/rwdsDPLgANfl57G9NhJEcizq2JEC3Fd0eJpwj874+3UmjG2Bi7mHx7w8YXydcst/D37IMczzRhi3aO/ujMCy6bP/sT3o8xZsp4kliceQj7O6biKnOdwwgm18/TiQXZAddnZe9rSJvMa/SBuE7XUMWKV0Xtak9bKseStVjUMDYj0rmrQXC+o3WWLHgN0jCqc/AGKpoOMDjCfdhuaN2ZlVXetO5Ymho/N02l8J42pd99bMCRWTjeu5Ej3NYVr62IkDJVhaUT30u5zD7NbbqE8spNrECOXEfobicHygnALaPiNvp3Mcu+kTjPocKEf4QAF0fZ0nV8Q6B5inaVS/q7obwvY6iT63DHxSAdgeN5Lv1adHGC8TKDtQwhwffCoPVtqzQGi1YX3fYzrYO48PLhjt5YnCZG9OYv0Zsa7G/dK+NQv0DsctdJuIVewAcwkfc7+77lafIPaoDpwF780JdJ4eclw8rjJOI2fRupo29YmkniWTVX6KYYzv97Xe7aEMC3nN82dnZGnc2UMBb25t6XwYNzMZ7TkUCrrHhXlZIRdRrlUgN3bKWgNv7CAnNpQTyxWshVDGS8uypi8Ae4VtCacJa/9pVIB5/M3bGsOuNtGu3sR5aMp+ra5zfuExreXvuU85/vgCbLgzXKNx3oFGz7nd/ucRPCnywgSkURSZxHnV94teejMrDx6jEuy0NeY9+gcvhvG//SWhNW7cmu42Y/q70aCncTEJrMAQ651Ojxh1jWcd4DmIP8+klb9rwCjcAOKoCKR6flbxNnIj12jE+czv5VW3r3t/4bwQQrfXtH+3Bqv5HOZ17zt5Vxhf8zXXvenTJv/ZME4ntb+zWRFmww30fL2e4nQGCBlf5RRLZBBrPOm2uU7mulDj8Uc//MNhvArL/X5Fz16pawxJxlmHKiuumuLErnJvbcJ+wf6+Zwfrky2g8RaBq4uj/mKeyv6OB98bxsWsxs58W9fMDLDv5AJ1kNfxtzc1dp46clD3c1tjdgrYmve8/8PONKuFNeJprKGOAkdzy9fnV24IHVSt6JmJAlqaU9/6kePHwvhTPyTswhbaxoUbmqcsrgjHkET/fuyxx8L4ve/drcuzZ4Xb4Zyziv1+rjlPnBBW4JVXXgnjSkV96OGHHw7jnR0hXqpbeu6go/vyi2o/t3ZUHmvYjzr2NY15+XuF0h1xDyiCOlHcv6l5RRc5cW1Tc5hj88IIE5N79LjmIXcfFILuqa9j/xsoYAcYsos3dczQUc6Ymdtt28OhclOnrbrkHL/TUV7wsWYuFtVW8gHmR6Pe2Hh+Vut55nbi7JlH1teF3jt2WH00/oZv937wugZ8R7+HNVwEr6m402nh8/FY+RhybTI/HjnSA+ZjhPcC9bbGzsj+Lco6tbfflAYGu4R3BUFL7TSHddVGB2tX7nkC7dVqKNdyr5713u6rnBoNPUcbyDeK61c+kzdhD5F7XGTZ8lmOH9ca9OzZe8I4C+wx13kpjMFcX3IZwHEs8mqHz7LHhxkNgM/Gu1+Os3wOdwJKKbL3HBu/58750UR8UkTf7/HToQH2P4IJ7wKduNrbr3/x34XxtbWrYfyJD30yjM+cPBPGCWC2ZmY0r+I++SRUlefxncXr7z2CUkI98tCVRb3359g9xLi1Xdb+xea25rdt5Pu3PSBsYgLtemcL77O5aI4gkMgIG7+vzrJnv+SEku/iJr4j53sen2tsMpaAb0de+ZM//4Mw/jDqs1TEe9m9nDvEe6sWUIk3b2m+fB6IyAsXhVKqAlfF91LEmrE+i3nt4R0HQvvkSb27Wl7WPjrfqdWArCuWlJsmyRxjTCaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUxvSdkXY0wmk8lkMplMJpPJZDKZTCaTyWQymUwmk8lkMplMb0m9odlavy9rHK8J67u+bMSGPX23pii3LacWyF6zXoNlPY4f0u0etpEubiuZoD3XQhhnYe3V7MsC0EntnrQPpFGvK5uoJmzV3biuWYGN6GJKlj3LBdlE5lOyuOt0VTa1nmzM2mBLJWBtmUwDFRNX+dEGqhnTORuO7r8xkE1oHDiWZIB6gLViD9bi61sqmx1PdZKA/Vs+rTIu5oo4RtdKpWSF1e/ThhQIlH10DrzQum090+VXLukcPf6do5g2VETwjCc9OBMIEBNREhEcCTFMkw6fEt26tR7GlW21h+u3ZRGVgvV4twPrR1iJZyuy3RwAdxOxj6PzP+zm0kBupWEjRjsyYk9CSzFaodH22lWbcuLAk8CSL9GGzbsHi3gkjxFvnn73kbqmxTaxJDqalntw8Iq0/QjaAs8Sgz//MGJHr7jTUb/ZBM6igZyUAXaoh+NpNZhLEGnljY3Te3kiRhRAxNaNWBl97GeBckH/q7T7Y+M+MQa0nAQugCglImQ6KLMRruVH6nD6NIDtXCKnZ0vGxqMumOu+X/tGjpH826gtpjP284j2kRHEZsEisAjUxMlTd+jPiA5DQ0nBkvjoEdna0RqReAKKdU2MURzer6NgfG6mzV4P9ZAE6oE4Bi9i2cs2D1wj7xPpi47+MVpzwnaamKxkYvx0Spb+k+pmvFVkzBvfR2mXzGfyMJ4RyeR547//TDvmCAKPY+poujtj5BmAYEnkZJc46sKC1yd2U2NOH3PEHvKxD0tbLwEUHZB3HuaRAdEPaA/MgZnS7n2WVo/o32dkAekBc+IDHzgaqr/yuVMZjeNuAjazuJc+nqPR0PzBBbIzl9V1Wxx3afPuqsxKyBnxtI4vHZa1ZfHIuTBOlmSnP3v3h/R5XvP6wTf+PIyrZT2Lg2vl5mBN7+rzZBLjCcrKD3R8rrBbD/01zYUH4NnEkEeIVfLQMYcObXqB0kOuLmR1fLuOyURcuaOP8w8domp0zgxQV0Fcc/Np1ICIXeCuFoGVygJ3lUBuTiSJP8AzR9xk1Z4H6Mc92nCj7+Sx5lqaVftsY93U3+PjVGvAz6Ii45jnBpGJCeZ1GEdpOc3BhFggDzgNUt7imD9kgT8olFTvOaB9qmXZrBPJlAViiWMF8UlxWCfTVrsHHBafMQdkkY+bLsN+eAtW/H1cdxHoo25X+Wa7vLN3X2oTi7PAJBX0rMyfXdiGbwPD1IXVer2p3NFB+6jWdAznQsWC8kgB8QgTMFoq8/xTKYzh8Yht+l9fPsaBJ6/p+b/2dWFPVs8IDZEujUelBRGvdC429/IB1mqRf48gk9yxMfeOos+Kc05ALEWSTZTL7Iz7H6ITvvbll8P4N/7Nd8L45g2Nl9OOpTT93WiEXFvE+Ncd6fMUMMiLWeW614BdObWltnRiVbmxua1xYHlO895iSe15IfO2MG5VlbOraMNpjBv3n95FkQw72oe8fVt7UNtVje+jtGzqf+SAMAsnzyr++peFV3nsya+FcbujcxYyGp8Or2gN6mCfaGPrahgfPHAEn8vKnhb0HDeCoeL+QOU9MyM0y7m7hKsZYDzpAZ1HHB/n4d2e6pPjJdGMPJ7zFh/jZZgnkPte29I1FzEHOAa80QPn3hHG994jjE8H+wZVrGPbWFNeeVX4txNLGv+ur6mt7DT0fOWsyvu+T/9UGKex7zONKmOtdAXtyivr2Q4cEJKn2tSYv5BVOZ44rGNadfWRh2bUFwIgqRwiIhc1Diwc0Hh58ZrwRbT+39jY2L1HrONngCrZIooSc+oW5knPPitkGc+TQXk0gQ3mfkcSuOJ0WvXbxT7qE3gHc/Kv1L9TB7W2yzz87jB20rqH9iW9F9j5wy+EsY+/PeACx7qgtbKbV86an1e7zaT1XEReJPB5LAV8QwbYGMzVj57YzUMjYLK3d9T2R7769uKi3hUdOiKk+He+85yuD8zpyVPCPSXwTqiLvPDbv/P5MP72k0/qupiXnjktZN0//Sf/VRivrCg3TKPaTa3BOTfi3lwc5cJ9V76XiPF9Gtp2H4siYo655+g4fDeIuRrmeSm89zhy5Nju9dH20wHWAthPWVlVO71yVW0mmxPKpTSvOqpUhBEjvpr7qESecJ+YeBjXAdYlso8KVCJwZNyz5fjk+7oHInOPHz8VxotLavNEBCfR5yJ7p3hH4EUQTqof4ntinJ7vIcsXFrRGvL0mjJjrjF8rEM3F3BdBWsXG75H+jRRZu0z33N91x/c/zkuIjRx6ahtfffHRMH7uyrfD+F33fiCMP/ZeIXmI3Eokua+u++H+dRQzic/3yjSIvPRTzCo9sqT2nkqrr7SbGmeJEuRan7nmzjuVs7v4DgBR1hFxax9L0GDiQnx8G46cMtKsJqCaeAjfb/hcb6Ms8Y72uZefD+PH/rP2Yz/1sX8Yxvt5iPs/N27cCOMLly6E8ZUrl8O4hn024uLiyM8sb2K47zh+LIxPntIe8+qKxtoM2hZz5RzWRQtzyh+TZI4xJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZDKZTKa3pOyLMSaTyWQymUwmk8lkMplMJpPJZDKZTCaTyWQymUymt6TeEKVEG6AY0Du9lixqZouyDoznZJOzti0bPy8+G8ZDYBRGA1jgwpI8nZR9TjYne7wsLJCIGRj6suQp5nctc7JJ/V0/JYu0BGwBs0nd143q1TBeyMlqZwh7zMtbsATqynbQwb17sCQqFXS/8wVYOcHSekAv7QGwKC4wRjh/A/aewzjs/4C2qMGirgHMUwz12airDmtVWULtZIBtgrX3CNZxXVimB/B18vbuOQlb2IuXXwvj6qYsX+lUHMEhweVusvMwLaOAUqC98vfpGT3tLsdbG+pbG1uqoyoRN4HKvQlMRLuqtpouq22MPFpQO/hccRI25znY3XeBeEgkgUSC9m3r+O07d8SCxlVhN0zb0TjOTXs12nA5tKEdeyfRa9Fukegu4kS8iPM2PkfDGrnAb6BPuChXYmO26qqTzZriAY4p5vS8tIJLIv8uz8oujGiiqG/b7j14E+qS7modMiBQDQfmgNOAp+EA9UAMVBt4kT5s6omYGSEJxXFzCTxsZ0Cry+lTEtaatLMkYo4YOtoFTmqgPA/boT8c366i6BtglTgu9tTX3cTu+BBDGyjOEM0By022d+C5nAkInzielViECKZsgq1kFPPDZ4p0zDCk1acTsV8db704iuD4iE9Cm0efjsWITSPyApgQWoymiZhQLo6Uw5h7icXG5wheM5qPgBHA89EONNIm0FZYlJF2xjw4abwMYhP+YTpEHGIMVq6R8Yw2ob7GraCj+mL7GWIsIvVhNIClLeaFAY5PwIZ5iHaSABInvmcJG7F1Bh4vOvj0EOsek7DAbsN2O4pVU9xpaB5YgT24D4voXl9tvwAr3yTG4D6Qo25M1z08I0vd7JJsLuNpzbFZxumCbLLT93wkjHOrsvzf+vZv6LobsqMOgMVwiajx1L97TfXXmWUd06rsHuMR/8i+EpmtECOnTzEdd7poE+k883ww9vj+gDlAcQJrAriBOgOskeIZYnqmT0OsNQ7kVY4LBa1NOF9JAuGaTOnZiB3iPK9DJAHGokiO94kIgmU9+l/b1bW2antzY9Qv14gch/yBni8BRIOPvpImdpOYvRSt0tX/+pg3LuFvZ4EfysOSv4m+TiTawuKiroUx20f+9jHmpDJAHmJs67S0FvQHxDuEodNqqhx2gGmtwk44BxRUB1jXDdj+e3vewitLQqzNzQIbBdv+TlvX7HRUfts7Whd1sCZZ3wIuBPgk5sc5zH9mYK9LjGOjobVTta7zdDHXm0YNO6rTrZrKpf+3tM4t93SiP35Cdub3PSA75XsXtf/hpbFGjKCUYq+P+e9vCp8UG3v8REzSpGMmWp+jfwDL+I1HXwnjX/7fngjjF55XnxiN/pYK3PT3Vum42tVsVjntRlP5chVY6yxwjhXk1BcuCDnSwZ7nwqz2YO8+JMTL4YzOs3VTufyBk0LfEm2XXdDfHlrczcmXzguxw/x39r77w/inH3xnGGfayouvYO/v0gt/Fsa9hpARdx3TONTqY3z3hSbbqADnjTmDj3l3A+ODi73TPvZU43H97eqK5qU/8ZlHwrgE/OKgp/tptTTm1DCXZvpIYZ48jMxDdAzXkfzb6Po1jMLPyl3V31pX1/lHH/jRMH7oLiFVXIxnPsYq/9tXw7iKPeA+2mJZ07XI/tEA6AAX2JiFw3eGcTo+3evFew+orxQXNO84ffREGF/dFL7srhUd/9BJIURKwG+d2Ab2CJP3v3gcWIm7dP57V/Vu4qULGkOee05rHOJbnnhid2zhXsmJEyfGHlsq6X6feUb4su1t4FWgfUyT40TnVQsljd3DNtDRmGNxv+GlkeZJf3Fdz/Hh/1PvTLJ/+Pth7AHBUn9O6IZrt4STuvaAnjGPtleaVdkfXlHuaTeuhjGH3RHG/gTm2IGjftxC++c8YLCXZ8+/LBQVX5sliMfANVcPCu9w4MB4pFEUEaL4wkWV2XPPq2xYP0RcD7GXlc2oLRw6pHuYRi0saM3SbKn8I2Rz7IWcBMZke0tzzh73JTm362AtxnUQcnAE7VrRWiKVAs4Y6+7SzO49X8LYtlVW/1/OqO002jp3G/sseV/t7tpVIUcS2PfmmgWp35kBeimfUh9NpnX8hQuagxMJxT3p9733PWF8+YpQqGtAE0Vw7FhLz6L/lYpClHBtH3DvEjFfV3DP341g47Hvwr6b3M2t73iH+vwrr7yqE+JZic6KvL+JvHMAvmnCuOVO3Bj93or+7d8EYvt3r2QK6ywgyIjO87BW62Aftd5V391pauzceFxt6alXNBaeWBQCM8CeXWegMWQwwjyJGHMcP0zs3sN6WzjO9rNa93/6YeGbluaVa2KYp21cuRrG12/dDuOLN/V5daD3KL/xxV8N4/984fEw3iwD6YUUFJDy5HMt6I4Noy+iJ+B8J8V8NxKb0N5wP4GPPhfXidqY6/7eH/2HML7njPCc3b298xs3NV4TmbS2rjpptVSvHOdi2BhlbiLK+vhRtZUzZ86EMcdUfkck2l31PzMzmg8vLi4730vmGGMymUwmk8lkMplMJpPJZDKDqdwhAAAfYElEQVSZTCaTyWQymUwmk8lkekvKvhhjMplMJpPJZDKZTCaTyWQymUwmk8lkMplMJpPJZHpL6g1RSqV52fKlUrL6DGBLlgayqLq+E8YeLEOJMKBNfSYlS650WueJw1Y8D3t8+hJ1+7L78QJY8gx37baSSVl0zs7LNjNwYaPWkx1UxdW5L++cD+NGHZZRDV0zC7vv+YJsARPAD9VgdZ2Av9JMTvZjdPjNoYzziF2HNv+wEEft0epskJb1YeATOaN6i6HMOj3ZvDWbsg91PcUZWEQmgLqhBdO+u1+rJuupG6/K1m3YG49IcSeQUya7mBE9Mem7XeNtkaMWzLSqmm6rs3JNVpKNFqyxYTtXA96hCUxEt6V67FRUN7Gc2tgA/XIIbkACdlc+bN+7Q50/OSQ2R31331qPoKUYyx829QGsBum350bQLLB7Q8x6dKPeYjo+YlE23mbPRUOkhWwE24RjaNfpw9oyCSvkckN1tYPYpz0c7plYozTOUwBiqZgnbknH0AI+tmcNmCBqBQ/Vh00+MS25DOzVcL4E7oVopA1g2GjbWAPii3iK9ARsDO8z6j83fep0kCMn4XyQI/vIr/GEPnfH2idH8Q1EBrZh658r0j4O1q/oo7EEUFh77YQOe7yvGPoccUsjtOtBD1intIfj8bcTkD98jghBDeePxXRdlgHtVHlOoouSsMgdwouV1plE7XlAk42Q73g/QWSc0T3zPpkred0OkIfZfexNxDpbMes+ggBi3sG9sK6GEbwVsUr4U45/OOUAdt9R9BNy02jC4Dwl8ruwF47D9hPHDIE68TEfGmEMGdLuNU00GBCisMZ1gcwcEhsH7AKxmgGsQfe7SNRpFWgt1GkMc2Hiv1yMs6whVlcLOMWdKvBJPcyjMSdL1fV5Pq2+lc2iDAKMQztq46mSrErnTgI5k1GZeSnNIZmbYkA0JoBeCu7/RBg3n5H9vudrDtNDG65XVT6lGZ1zOER+bO6OV6MAmJsE8VC0t0adYL7sYc6biqn88lmVX78/Hs8Uw99G6hBz8wDtptfRORMxjbXTqLmkyn8Z5Z9EG3Y8jX+5vNZBHo9BvyBiykc/6yLXZTE34pqOcyOOSxmslTJ7mAuuF4sxWVQ3mxpzOcYkOa8i2o4IRcwBiOjbLsvut5jFWrcgtE8igoXD2g64iQIwxgsLsopNoQ03MR/wgGvLoO31O7C65fiHwaJeV5+r1XV8G/buMTAjONw3YFOfwDhTyO3mgEx6/F5BtSr07g7KrI08vLmtzwcYi4m1ZN0uo5ySwPtwLl+GpXqlIpt0jvXZvNrINKq5ozq6sKY4hefkugyrrzclrg2evaE28NtfkLX5zJLa59F3Hg9jF33ESYxBHEVQS+OxShPxSZF1/CRM0gSUEjT01c9uXr4Vxt98THtDn/9/hKp47nm1GZ8sANN/8To8o7lOG+MTUcIpjCfEM3ZG2JurKxetrcn23Rkh150UDumFZ2Rf349rrH37O94dxo1Ac7Ia5iDX1nct8dcx/1g9IAvyIwc13xtg/KgM9UyXX/pOGL/rnOaEd7bU/z/+Ye2dnjiu3FzDftcT3xJ+7/cfU3mslZVr0p6Oj2EPNoXcP1fSdf/l//Lzuu5hldkl4KpQrE4LGMdGC2g+rrkwE2+3sS7Rab4Lh0yU7ev3obifkMC8yQNec6eqNpE4JXSKC6RKdl3j6Mqrsvyfqeg5qssrYbx0QO31niMa5755STnurk99NoxTWR0zmPL14uKq3jnEgEM6+Lb7wjj79F+G8QAk25PAVb70tNre7ILGuZsZ7b2/fF1l7W0IMZF9j3CxO0ONwj3khuh+5es/q1RUp8QncZ7GuN9XvyGS5/p1oRDymNNkc8oLW1gzx7H3wWNWjwt50Dt4KIyf2VT7PLQmZEvnWY2d17D3+80Ztdt1oC2GePbMuvLB0xfUJt9+/7Ew7gPLwbl/DHPyKMECaN1Ih93t34GjvyN2JZXUuYmpHgHXE9lTGo3f0+H85NJF4XU6beU1rv8jSHHsgwXAVlwF2uLsPfc606YTp4QmW9/QHKtPNG1az+nGx+8ZBG21c/aRKnCqTaxBcsDxsa77wIRx/VIuq6+9/MIuUmtnR+86E676U2FZ9+jl1JZnDwodXVzVHseij/eeLeWjfkN1V6voWgsn1NcXT5wN4xdfEtrJCYChwSBGRMmDDz4Uxj3sA68TpYSy7GH8G6Adcu83jn6WRr/Ipoge49xebb7V1TnbWOdzL7K4hzl8+F0Php89+Q0hTGstrHVjfDnKPgq0IvZRiVWKomq+91x+EjIpurKY7jVBo6E8U8xrH4L7ZM2ucouPdwH5tNp8d6h24mPPs3pVc8GLt14K48W02nxrW/fQ9xW3Y9h7aGi8ql7b7d89ID5vOOo3/YbGhn7rg2H85Ksaux997Cth/E2gB8sYX/l+7vnXhBbtxNRvWshBUUoSX3Yw349/DxZ5DxR5r0kscPAmYgfCWDHi/eAQ3gPu7aXzwiL+7h/8ZhgvzO6O8f9fe+f2I8l11/Hq7ur7ZXpmZ2dmb971jtfrtddO5EQIDMQokUggRkCIhGThp4j/hGfekfKeJ6SgIMDBimPzALGN4wu78WWVvc3s7txnevp+5WF66vsp020wkaA1+X6ezpZrqk6dOud3fudU+/vdgjV2Hbav/LaQiFmpYe7EHlR1QeuTS7BPunJZNp1nzyqvKBbV50aJyd+H+CIq+F62smIrJWOMMcYYY4wxxhhjjDHGGGOMMcYY82uKfxhjjDHGGGOMMcYYY4wxxhhjjDHGGGNOJJ9rpZTtSgqs24a1AZR56vuSE0rmJRFWnIO1AW0AupBGw3WaNcketSFju03FXJTTWUkWpiERPRpbIs3NSaJpIZCM2XxBkj1bPckAlUuSKMsXVL63JummsAcpN1jMNLKQlB/C+gkSPxuQQ9vY132XKqpbKa375kI9XzELebaYUwykziDznYek3ybkm9ptWFrBsmUEqSXKAVI6PAvZ6QFsWFI9PWM+dyRv99E7H0bHajuSV5omWzzNMomyoxnIpYeQZhv2VPdOXVJ4FCxM8PdfMUUqWh3MtpVSszXFDoKS5ZCgq8NWqQdZ8S7sFVKQ7mz1dJwy2SH6cB0yjTFPFkC7nuNmz9AaKS0JxJivB+QgKQkWv95kie1RIv62o+M4OorJVkJ6azhZeovnBElKncEuAZKPlMvsoL330Sf3GnrGHMZTGvLfPbzbfE51KOUk5UnboRyOD/EsxxKHlDqkFHwioTFEqflRTLYfEqqwFMnADqiL+t7f1ljHrWJ/y/jSG1DLjVYxsz0Wi5CQTUB2rt+ZHEcpHxeTW0Wfoawy31MfbZQvaR7odDRec5gLaR/Bnt0bS7vG7om4GJN7hRLngPYtGH+MKZQFZB+c9ny0VaLNRge2OOy3lI3tdmhVw+SAY3Q44ehnbIFQ5zQseHgOZTcpgcv5KhaScM025IoLhdy4LpPt/eLvZLL1WUyuE/Fxms0U7aHYfomYlCisqyaH0CA51apwNhjQSimFnAYyngNIxfYwj7ZgycFcqt+nhRwsppK6Zg9SyX3MPzm0dXFB+TA9jo6tkoZT/LSGkM/n+00i7g5h08l310Zed1CDNCmkaocD5j0oQ8K/3VSfbO2oQ/RHqlsxhKR89nZUPnVZktlpyKxmkHsPkW8Np0iIp+YkDZ9ckfTv4L6kzhs1nA97tDzWH4ePkLeM322Y1bn9Aec2xk/MnUPGGt2zUMQYxdgaDiaPdb7PAbxQQ0gPd7qIxUnkGw2tkWaRBVg8MraEkEwtlLUuo13QCPEtNg/0Yf8IqWvOM7Q1ozwyLRWasBbtDnWd3PidlfIwlsGcVDuQFHwSdexj/Gdi1oMajOWKpOmbLd2zgfLpeckWJ2lnF7MlUrlU1hqxAGnsMnKSdhPWSIjfYUbPRfvMQ+QSrbbGdB92qTXY49brOiefVRuXmZ8gPzjsKlblsnrnldLRWiCNcduBdPzamqT01ze2ozJziUpZbbxS0f25hmmhvUPkuhtbGk8N2uTh+sdr2iAIghQsgGjDNIvsPFC/rcDu7S+vqf+8dk/v8e263tcXFf1uYL780dva58jnJZ/9Mi564dlzUTmziL2N41eZ1zsKMlPWZCPmJVOskabYMMXhHKw22L67EZX/5q9+HJX/8VXNbZvbOn84/KKtZn5dOFtVjN+E9c0Aa/cm4mUba+o2um0NVkpZxMyLS5oHMj3ZR7z5lqThC8uyraj+pqyUagnF47duSia+PbZeoT1e/wB7Su/LuuHMwiPdH3unDfztd196KiovnNPceWoOORP2G4pZ5T0vfFlzWziUxP27H2muoP1UIoAlRoh1eFpzxXJV16TE/e62rCQqcys6B0l2HzLxna5yFVrh9GM2yZMl7gdTzplkoxPSvhM2p3dv38Kl8awot8uKsVtX8EyvwvpiUXZSxQXsbSPnmpuXlVB1WTGc+zit9hc15fu/pZXRXsnOPdkunD+ttclTT6mvbmLPLoAt0BpsqHZgmVLF+uH5i5Lsf/qs2nd/V38bLmuNeO6c2nRjQ/NPb7zPmJxiCUKbJOafDVh+sdzDvuVbb8lu7etf/4auj1x3H3GnBKuoSkVx7Tde+J2o/OevfC8qN5u6L9dEjx7oG0jzgWxyr9+/H5V3//nvo3K7CTtOrIPLFVmxzVVlwVDo34nKtImO26vq+NI81iVZWPuO99ZCWD4OenqmUUrvvt1SPNralnUW23vaOGf+8OTVq1H5lb94OSo/+OQXUfnuA8XcL+Fb18N/U8xfe0rv7dt/9CfBrJHAvkl/yr4k+/Mh1iYDfB/rD7AuRr/N5Gh3qrZgu6exNs2hbzNO97GXt7919F5XEP/SDa1NWn3ES6yHrq2obyZj9n6KxwXEpu0bsD57gFiAPnZ6SfZ3uTs6J2avjj3JHCxr5+cVdx67oGf5OexkuE+7va1nvPWprL6urV6MymXYAuexn8HprIk5/rCpPIB7HtwvL5U0Fgu5o/YZVTXmf/+l70TlN15/PSonUrTJ5Voa+9CxvQLUV9WN7cX/D1yVPvMtk3vSM74+wBquDzv4LtbObeQCPdjfcS+B80YPNl5sR+63rzcU7ytFjde9lr67V0+pD+S0VREUk0fvOHtRuVy3pRNur+vaf/3970flEHkp58VmU8/Ux3flBL5HtQ/UBttrGhMD+BKlCtjbRF46jOWBXKf+97ZKMfC3cTtAWibhj6ctffuTD3PviftW//DaD6PyV6+/GARBEGQw/5FwytjK5hTjlk7DRvXypaj82Hnt+y4tKT6WitgrQx0HeG58no19j8li32lxUb+5mMZsf/UwxhhjjDHGGGOMMcYYY4wxxhhjjDHmf4l/GGOMMcYYY4wxxhhjjDHGGGOMMcYYY04kn2ul9HBNcnCjpKSpqguSbhvkpceTzUL2HbYSfWgCFSGNFUJOPZWRjNIjSGz1kpAdTEMeP0UJfcnkhGPZ4F6gY48akr+t9SW7VElJUuep5eeicglSeh/sSg442UJzQaan04U9DeR7s7B4CoZqv/265EBrNUnQV4uSN1ssqY3zkI0LYYFy2JQ83N6BrknLmzZkyRuQE485J0ChOAe57TQk3ygX3oQ0YApSpYfbR/W59R+SqKQuGSWVYopjOCdb0j3PXZPU0qXnLkfludNqp8tnJFH37hvvR+Wfvf7vUbnbouzXZOuJbmuKrtSM0O9TI4oy8pD5ghxavQerB8o3ouEHkJDt4vq0ZqHEY0zuEJKU2ZDjQsVwfE6Slh2Qt09Q7gv1TfQmyyryWaeZ7Yym/GMUTJbKmwokzSitPkTb99BmlHxswrZiE9JrHUgkJ9nekEUuIIaWC5RcVEwqQvafcoDDgPJvR21OObaYBRe6U0wGPGb1Aysl3KeM+y9Bkpjt0Yq9Q8H60NKDZw1nXXYwmNw3MpnYk078S8ZASi9nEHfDkDJ0k22YKHMZj2mTLX9Go+P+AKsenED5zfhxyFBCUjBupaRiEj6LrDvpYazzvmm0Aa0qaLXA+YbpS1yqUud00casTwg5Xt4rdhXGgCQbc/I5bIfF05q/j8cRLQtTSd0/mYB1QMyuA4OUQxTPQVlvSgYnYn0C8Tkm5Q3JVdrA4HivO9vS2KMe5D1hw3G4K+llShkzALXasEIYqJzLK2/rQEoyA0nyFPp/HZZFGN5B7hTkmQuwOxtL5g4RO/pDyi2rn/RgjZRgPwkoJamjtZry5cN9tUES12Tul4u5TMJKCSc1erpXHtY+CPHBxx8qjx0mXovKX/s2ro81RAH9lmMonZNcZq+FdxhKxn1nR5VOB8q951c0R7bqaDdYwiQiWz/MxbRygXVPAtLGAWy0RrDu4Tjr9mlVw/UPrHYQs2LyslnOKZpTR7Bs7c24TP0CrGySsCMqwi42hH1Sgvk35oQwFt8mzw8cO5yDu131/xYsgjq4Pi1iw3HcS8yp7o0+5GxpDQid1sQUeWZaz5WKuuZhvY5zOK+g7rB8432z6IeULc6mKRet85tNrI0x5sqQvm9AHn+A+S/BlBz1GQ4m53MB1gGMVWkcr+K+zH+O69xpw8YIlz4Da4FyVRYdu9uyC1k+I6ndNOboFq45wLtqQBa9jXPyMZlx2Srw+bpop/qhYv4sslBSDPnu72ntXK5qn2Xj7yTN/y6slH6VlfAeJo4fvCG5/0/W/yUqP/8M9l2wxl995sh64swVHStd0LmpqsZT3MNysqXm1DLmwtaOZPg37mm/6+03JRf/05/I6uHR5mzHYDN7LKPfJmC10IEtQgGWbTuHsB+J2anqmrTSTcF68/5d7XWuw7LlcFNjfW1dFnU3PpUVz9auxkI+fxQ/aBt8iNi5tqP5YwkWM5fOKo5U5rU3d+dTzUM/gdX6c3J4Cp58AnvMBeU9F84pZiUg4Z9BLnr7ge5bayGPxXDtwK67AWuWbFZWVDtog2JJOWeIeSuN8j7nrinr8y7qPJhicTvJaqGA9VwOOUB5XhYae+gru3t6D4tZxU0u//qPL6juFb3bDHLaZ689EZUf/VL95uGG7G96LdjJZHWdew/Wo/JXgmf+yzP9fxMij3/62vWofOWq6tpqaN76yh8/H5Xv3JLN1v2bendXKspNlrHuP92GDee8+nBlUflFErYgGwfqk5ubmouO1/XcI+pOWZezT3HdewjrXZ7z8KGeiValQaB4tDCn8cFrhiG+D+Bbx8pZ2mzBOqWhmJVdkM3UxWf17eUFrKs37mkO3noka41iQf0tn1LdugeykynARSduS8r9L+6j6/wM7EGP90h2dnTt2Foa57YQH3cRR7p4Jo7yabZKLJ9ZkQXXhbzqvjinnHo5q4fdGcBGrqZ3PotsbiqP72EzIeaQjrxtbl4xrb0lGxPatvL/9c/Dujmb1b24R1mEfct12B0NYau5uyV70LMXj865elUT1+6avnd17t+MyvVDrflWn5Z9YaGiGJzFtxZae/Vq+p63eVvXHGF9y/E3N6fnGKGXxfYe8O1wgD52eVXxnnZSbdjS1OrqS++8805UfvlPvxWVS1hzcG+73tK7bcOSOoG9gHxedaO9VRJ74ce14Xr/d198UX+XUcz6GLaQfXxn5vqc+9ncO+U5A1iyx8doMJFRbG948jmzSArfBWil1Meavoe91hHGUBd5VQr9rQvb9QBWWSvl81F5r6cceLetcdYcauyUUxrH8yXMneVx/0fAeGz1UlTOPq9+tLupa9/+6GNVC3scCYx57u+MunqpB3cVd2rrumZhXnVIY1O1fYBN0mDyN4RYR6FUyWDKOeyHAUlOPCf+sR/PxWvi23EA284Exs7uvmLo+qOj/d4rl5RD0T6dvx0oY998ZVnz/urjq1H5/PnHcL5iWQ65Ja3RY/kyxugwyZwatnoY3xVYkE/DijHGGGOMMcYYY4wxxhhjjDHGGGOMMeZE4h/GGGOMMcYYY4wxxhhjjDHGGGOMMcaYE8nnWimVTkkiMISdD6XpBgnJ2HQCaKBBri85gjR9UxI4p05LFqmc0vUPdyHbnJeUTn9Ui8q9DuRzIP3f6R9JkNWhodkcQGIdVkrzC5JhLqUh4d6XJF6QVX3PViQDlE/qOs2eJMcGlI8KJP2Tg3XDHOTi213d68Gm5Pq2IRUX4vdLh/uwTDqUVOMmrJTClCSkSpAiqrdpP6VaQmEtKEJSPJ+cbHtFeXPKG63dPZIcbjd0n2QI6TLIH1EtL1tR/7j6Ncm6nVmVjOD8omRNq1X1m2euSALz+nVJMi4/Idm9h+uSi0xBpr4LmbCDLbXlLELpKCq0UQ5uBKeFbgZycEX8h4LaeggpLdpzZCHZGZPq4vkxWyNKz0PKaiwHP4QEeYpeTpAVTtDOhNfg/fnklATDWeimwZDHp1jb8G+pzsVqsoyqxayDWJ8WZPsPO4wHkNeFrVEppwF4CpZJ5QJk8Et6b6kUe8Dk+g/HdRtOkf+jpG8/VtYzjdDeMUsf3J5WSrmMnmNzX1J4tOxifTp9WrlMti+YRWg50oNMchK2F7QJG7DTAErjsn1p/0ObhoDnQD40k+XvW2nJwbuNxscm20AlErBgmvbeKSed1nsniZgVkMYBn4OylXF7PZwDWb5kTE58Wt+HtGN3skVVfwBZSMYkWj6NKMUX0yCceD6rk8Ecn5hg9TFNWpNjkXGYllrTrLli9km0i4sFM/xBzPZq8u+iWfdkcrId1qyAcBX0MW46beVke7BVYuxKw1Kl14OtTQ6xHJYZi4h11WXabaBCmCxi1iIlyTeG5bGULvK0ER6k20H+RMskSEYypnQgb713ABn+Dqyi0AcKKf2DVU8jD6y3dd9qRueHeL6QcRD1/8X7ksCmXc5voxJLlySdmUaOmi8pb6vvSOZ/b11WTY263vOZC5DXZI7a0Hsbwg5uUh4QIvbFrY4wd+M50mnYlGHsDmCHFSL/GsGeaUhde8zjVINOF7M4PnmenkXykDgP08pjCkXOFbCtwhjl3MJ2Z8wcDjhHiQTidDandeSA9owYOwmMndR4fVLg3Iq+XEbd27CvYB7Dci4L+9yYpR8sIJhfo+7tJnMmBDbE4JilA+aHwwNJtzfRrgtLGk/pKfaBlNZngGTbVyqSt6U16gCWaJTADkO+Z+QzmE72x3LzCejeLy2rvlmMs0oTkuMYw1x/pmGzuLWj9fA+7CZaTbVNHpZ5hQLsTnD9JuxOushjaw1dcxZZuKq180Jm8py0UsH6PqG9lf6vkH7zTw9gp/3Tm1pf/+vHule1IOuXyytH7/i3vip7iW/+oaSar33jWlROLUuO/jMr4inHAfr+7g3ZZvzTD34Wlf/2x5p77j1UnzHmi9JGHtbCvmQec04B0uM1JGKpmL2s/rbdVT/f2VPsvwMrpVsPdXzvUDnljU9VH1qjcA3eG99rMFCMzKKObYzte9w7Qzx+buFqVH7zpsb8q++oXldXNb4XCtrzfPJMHWXl7+WE4vFCBjYteeR+A669YTWONqO1dpt7xdxXRr7RgXUN90XYZpSPZ7tyLca5djhlX+B47VvGfN2CTexr78sm4vFF7dFf/eGPovJ3vvdKVFaUD4LlOfWtfh7tAbuLCvaallcVi9++pVjZwLxYDnX+1q7k9meR57GnXC5rT3nlrOyp6nXlfOcv4PtGXc/2Z996OipnYdlSQv6JVxbkq1r/Jfuwfrh4KSo/hP0Oc8T2OJ9jP6JVCcvsU8wh67Dy3N/XfdrIFW/cuBGVK3mNy/nqfFTeeKQ+QMuR+7Bn+/C996LywrJslUa0MUKcKOP6e3vI2xp6rg3YwuXn1bCDpGLP45f17SAx0HNxvMYssXG8hrxwkNKIKY1jANcktGjgNx6uEWkXzlybjKasIWJ7/VgfDLDXSIu77qK+YyVgrzOacS+XvR3F+zbaPwk7nwH27CpV5Xy7+5pPYo4g2FOey2sMPXZB+w0B7KaqFY3LAtYhtOq9eEm2SRcvXDi6dgnrBVjM3Lv/UVTm+rZU0je/IqzXUhgT3I8rLWgdlCuqjumhrpmAheLivK5Zhm13s6FxT8sR3nf1sixNzsGatoY4kYaV381PtBfz8w80Fz33pS9H5S72UVJ5tdVcmnveXGvye5JITViP9mP2xrre6lXF5I1N9a1hVxaA/HTCvc1UcvKczlwivh88eZEU35+e7fFHaIGUxLZXr4X1PayqUrRnhFfPEG1EG54BvvtnErpOGrnDQVNjutvEXj2+wbcRh8PxR+wE1v21tvos9ykuLF2Myn/w0jej8vpHsvV87wNZlj16qLp0OszZ6DWt8rnzypMaacWDBy3VZ0RnO7q/0dKPnn6xeWbKJn78Ay0uyW+l/C4w8Sqx7x6xDQBUhzZFaxt3giAIgicf15g7dWoeZcXqs2eUW52DzeLyknKxSgUWWVO/96C6sbaZbKXMb7v8oUt8j24yVowxxhhjjDHGGGOMMcYYY4wxxhhjjDEnEv8wxhhjjDHGGGOMMcYYY4wxxhhjjDHGnEgSMcl9Y4wxxhhjjDHGGGOMMcYYY4wxxhhjTghWjDHGGGOMMcYYY4wxxhhjjDHGGGOMMScS/zDGGGOMMcYYY4wxxhhjjDHGGGOMMcacSPzDGGOMMcYYY4wxxhhjjDHGGGOMMcYYcyLxD2OMMcYYY4wxxhhjjDHGGGOMMcYYY8yJxD+MMcYYY4wxxhhjjDHGGGOMMcYYY4wxJxL/MMYYY4wxxhhjjDHGGGOMMcYYY4wxxpxI/hOfUWnXdRQJDQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print_mislabeled_images(classes, test_x, test_y, pred_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**A few types of images the model tends to do poorly on include:** \n", + "- Cat body in an unusual position\n", + "- Cat appears against a background of a similar color\n", + "- Unusual cat color and species\n", + "- Camera Angle\n", + "- Brightness of the picture\n", + "- Scale variation (cat is very large or small in image) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Congratulations on finishing this assignment! \n", + "\n", + "You just built and trained a deep L-layer neural network, and applied it in order to distinguish cats from non-cats, a very serious and important task in deep learning. ;) \n", + "\n", + "By now, you've also completed all the assignments for Course 1 in the Deep Learning Specialization. Amazing work! If you'd like to test out how closely you resemble a cat yourself, there's an optional ungraded exercise below, where you can test your own image. \n", + "\n", + "Great work and hope to see you in the next course! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 7 - Test with your own image (optional/ungraded exercise) ##\n", + "\n", + "From this point, if you so choose, you can use your own image to test the output of your model. To do that follow these steps:\n", + "\n", + "1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n", + "2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n", + "3. Change your image's name in the following code\n", + "4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 1.0\n", + "y = 1.0, your L-layer model predicts a \"cat\" picture.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## START CODE HERE ##\n", + "my_image = \"my_image.jpg\" # change this to the name of your image file \n", + "my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)\n", + "## END CODE HERE ##\n", + "\n", + "fname = \"images/\" + my_image\n", + "image = np.array(Image.open(fname).resize((num_px, num_px)))\n", + "plt.imshow(image)\n", + "image = image / 255.\n", + "image = image.reshape((1, num_px * num_px * 3)).T\n", + "\n", + "my_predicted_image = predict(image, my_label_y, parameters)\n", + "\n", + "\n", + "print (\"y = \" + str(np.squeeze(my_predicted_image)) + \", your L-layer model predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") + \"\\\" picture.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**References**:\n", + "\n", + "- for auto-reloading external module: http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython" + ] + } + ], + "metadata": { + "coursera": { + "course_slug": "neural-networks-deep-learning", + "graded_item_id": "TSPse", + "launcher_item_id": "24mxX" + }, + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Assignments/Logistic_Regression_with_a_Neural_Network_mindset (1).ipynb b/Assignments/Logistic_Regression_with_a_Neural_Network_mindset (1).ipynb new file mode 100644 index 0000000..7fea41e --- /dev/null +++ b/Assignments/Logistic_Regression_with_a_Neural_Network_mindset (1).ipynb @@ -0,0 +1,1500 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Logistic Regression with a Neural Network mindset\n", + "\n", + "Welcome to your first (required) programming assignment! You will build a logistic regression classifier to recognize cats. This assignment will step you through how to do this with a Neural Network mindset, and will also hone your intuitions about deep learning.\n", + "\n", + "**Instructions:**\n", + "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n", + "- Use `np.dot(X,Y)` to calculate dot products.\n", + "\n", + "**You will learn to:**\n", + "- Build the general architecture of a learning algorithm, including:\n", + " - Initializing parameters\n", + " - Calculating the cost function and its gradient\n", + " - Using an optimization algorithm (gradient descent) \n", + "- Gather all three functions above into a main model function, in the right order.\n", + "\n", + "## Important Note on Submission to the AutoGrader\n", + "\n", + "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n", + "\n", + "1. You have not added any _extra_ `print` statement(s) in the assignment.\n", + "2. You have not added any _extra_ code cell(s) in the assignment.\n", + "3. You have not changed any of the function parameters.\n", + "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n", + "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n", + "\n", + "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/neural-networks-deep-learning/supplement/iLwon/h-ow-to-refresh-your-workspace)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "- [1 - Packages](#1)\n", + "- [2 - Overview of the Problem set](#2)\n", + " - [Exercise 1](#ex-1)\n", + " - [Exercise 2](#ex-2)\n", + "- [3 - General Architecture of the learning algorithm](#3)\n", + "- [4 - Building the parts of our algorithm](#4)\n", + " - [4.1 - Helper functions](#4-1)\n", + " - [Exercise 3 - sigmoid](#ex-3)\n", + " - [4.2 - Initializing parameters](#4-2)\n", + " - [Exercise 4 - initialize_with_zeros](#ex-4)\n", + " - [4.3 - Forward and Backward propagation](#4-3)\n", + " - [Exercise 5 - propagate](#ex-5)\n", + " - [4.4 - Optimization](#4-4)\n", + " - [Exercise 6 - optimize](#ex-6)\n", + " - [Exercise 7 - predict](#ex-7)\n", + "- [5 - Merge all functions into a model](#5)\n", + " - [Exercise 8 - model](#ex-8)\n", + "- [6 - Further analysis (optional/ungraded exercise)](#6)\n", + "- [7 - Test with your own image (optional/ungraded exercise)](#7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Packages ##\n", + "\n", + "First, let's run the cell below to import all the packages that you will need during this assignment. \n", + "- [numpy](https://numpy.org/doc/1.20/) is the fundamental package for scientific computing with Python.\n", + "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n", + "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n", + "- [PIL](https://pillow.readthedocs.io/en/stable/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import copy\n", + "import matplotlib.pyplot as plt\n", + "import h5py\n", + "import scipy\n", + "from PIL import Image\n", + "from scipy import ndimage\n", + "from lr_utils import load_dataset\n", + "from public_tests import *\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Overview of the Problem set ##\n", + "\n", + "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n", + " - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n", + " - a test set of m_test images labeled as cat or non-cat\n", + " - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n", + "\n", + "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n", + "\n", + "Let's get more familiar with the dataset. Load the data by running the following code." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Loading the data (cat/non-cat)\n", + "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n", + "\n", + "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = [1], it's a 'cat' picture.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Example of a picture\n", + "index = 2\n", + "plt.imshow(train_set_x_orig[index])\n", + "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") + \"' picture.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n", + "\n", + "\n", + "### Exercise 1\n", + "Find the values for:\n", + " - m_train (number of training examples)\n", + " - m_test (number of test examples)\n", + " - num_px (= height = width of a training image)\n", + "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "921fe679a632ec7ec9963069fa405725", + "grade": false, + "grade_id": "cell-c4e7e9c1f174eb83", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of training examples: m_train = 209\n", + "Number of testing examples: m_test = 50\n", + "Height/Width of each image: num_px = 64\n", + "Each image is of size: (64, 64, 3)\n", + "train_set_x shape: (209, 64, 64, 3)\n", + "train_set_y shape: (1, 209)\n", + "test_set_x shape: (50, 64, 64, 3)\n", + "test_set_y shape: (1, 50)\n" + ] + } + ], + "source": [ + "#(≈ 3 lines of code)\n", + "# m_train = \n", + "# m_test = \n", + "# num_px = \n", + "# YOUR CODE STARTS HERE\n", + "m_train=train_set_x_orig.shape[0]\n", + "m_test=test_set_x_orig.shape[0]\n", + "num_px=train_set_x_orig.shape[1]\n", + "\n", + "# YOUR CODE ENDS HERE\n", + "\n", + "print (\"Number of training examples: m_train = \" + str(m_train))\n", + "print (\"Number of testing examples: m_test = \" + str(m_test))\n", + "print (\"Height/Width of each image: num_px = \" + str(num_px))\n", + "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n", + "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n", + "print (\"train_set_y shape: \" + str(train_set_y.shape))\n", + "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n", + "print (\"test_set_y shape: \" + str(test_set_y.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output for m_train, m_test and num_px**: \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m_train 209
m_test 50
num_px 64
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n", + "\n", + "\n", + "### Exercise 2\n", + "Reshape the training and test da\n", + "ta sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n", + "\n", + "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n", + "```python\n", + "X_flatten = X.reshape(X.shape[0], -1).T # X.T is the transpose of X\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "5a2aa62bdd8c01450111b758ef159aec", + "grade": false, + "grade_id": "cell-0f43921062c34e50", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_set_x_flatten shape: (12288, 209)\n", + "train_set_y shape: (1, 209)\n", + "test_set_x_flatten shape: (12288, 50)\n", + "test_set_y shape: (1, 50)\n" + ] + } + ], + "source": [ + "# Reshape the training and test examples\n", + "#(≈ 2 lines of code)\n", + "# train_set_x_flatten = ...\n", + "# test_set_x_flatten = ...\n", + "# YOUR CODE STARTS HERE\n", + "# print(train_set_x_orig.shape[1])\n", + "train_set_x_flatten=train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n", + "test_set_x_flatten=test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n", + "# YOUR CODE ENDS HERE\n", + "\n", + "# Check that the first 10 pixels of the second image are in the correct place\n", + "assert np.alltrue(train_set_x_flatten[0:10, 1] == [196, 192, 190, 193, 186, 182, 188, 179, 174, 213]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n", + "assert np.alltrue(test_set_x_flatten[0:10, 1] == [115, 110, 111, 137, 129, 129, 155, 146, 145, 159]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n", + "\n", + "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n", + "print (\"train_set_y shape: \" + str(train_set_y.shape))\n", + "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n", + "print (\"test_set_y shape: \" + str(test_set_y.shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**: \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
train_set_x_flatten shape (12288, 209)
train_set_y shape(1, 209)
test_set_x_flatten shape(12288, 50)
test_set_y shape(1, 50)
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n", + "\n", + "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n", + "\n", + " \n", + "\n", + "Let's standardize our dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "train_set_x = train_set_x_flatten / 255.\n", + "test_set_x = test_set_x_flatten / 255.1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + "**What you need to remember:**\n", + "\n", + "Common steps for pre-processing a new dataset are:\n", + "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n", + "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n", + "- \"Standardize\" the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Building the parts of our algorithm ## \n", + "\n", + "The main steps for building a Neural Network are:\n", + "1. Define the model structure (such as number of input features) \n", + "2. Initialize the model's parameters\n", + "3. Loop:\n", + " - Calculate current loss (forward propagation)\n", + " - Calculate current gradient (backward propagation)\n", + " - Update parameters (gradient descent)\n", + "\n", + "You often build 1-3 separately and integrate them into one function we call `model()`.\n", + "\n", + "\n", + "### 4.1 - Helper functions\n", + "\n", + "\n", + "### Exercise 3 - sigmoid\n", + "Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid(z) = \\frac{1}{1 + e^{-z}}$ for $z = w^T x + b$ to make predictions. Use np.exp()." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "239ab1cf1028b721fd14f31b8103c40d", + "grade": false, + "grade_id": "cell-520521c430352f3b", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: sigmoid\n", + "\n", + "def sigmoid(z):\n", + " \"\"\"\n", + " Compute the sigmoid of z\n", + "\n", + " Arguments:\n", + " z -- A scalar or numpy array of any size.\n", + "\n", + " Return:\n", + " s -- sigmoid(z)\n", + " \"\"\"\n", + "\n", + " #(≈ 1 line of code)\n", + " # s = ...\n", + " # YOUR CODE STARTS HERE\n", + " s=1/(1+np.exp(-z))\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return s" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "0483e6820669111a9c5914d8b24bc315", + "grade": true, + "grade_id": "cell-30ea3151cab9c491", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigmoid([0, 2]) = [0.5 0.88079708]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))\n", + "\n", + "sigmoid_test(sigmoid)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.62245933 0.5 0.88079708]\n" + ] + } + ], + "source": [ + "x = np.array([0.5, 0, 2.0])\n", + "output = sigmoid(x)\n", + "print(output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.2 - Initializing parameters\n", + "\n", + "\n", + "### Exercise 4 - initialize_with_zeros\n", + "Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c4a37e375a85ddab7274a33abf46bb7c", + "grade": false, + "grade_id": "cell-befa9335e479864e", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: initialize_with_zeros\n", + "\n", + "def initialize_with_zeros(dim):\n", + " \"\"\"\n", + " This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n", + " \n", + " Argument:\n", + " dim -- size of the w vector we want (or number of parameters in this case)\n", + " \n", + " Returns:\n", + " w -- initialized vector of shape (dim, 1)\n", + " b -- initialized scalar (corresponds to the bias) of type float\n", + " \"\"\"\n", + " \n", + " # (≈ 2 lines of code)\n", + " # w = ...\n", + " # b = ...\n", + " # YOUR CODE STARTS HERE\n", + " w=np.zeros((dim,1))\n", + " b=0.0\n", + " \n", + " # YOUR CODE ENDS HERE\n", + "\n", + " return w, b" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "a4c13b0eafa46ca94de21b41faea8c58", + "grade": true, + "grade_id": "cell-a3b6699f145f3a3f", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w = [[0.]\n", + " [0.]]\n", + "b = 0.0\n", + "\u001b[92mFirst test passed!\n", + "\u001b[92mSecond test passed!\n" + ] + } + ], + "source": [ + "dim = 2\n", + "w, b = initialize_with_zeros(dim)\n", + "\n", + "assert type(b) == float\n", + "print (\"w = \" + str(w))\n", + "print (\"b = \" + str(b))\n", + "\n", + "initialize_with_zeros_test_1(initialize_with_zeros)\n", + "initialize_with_zeros_test_2(initialize_with_zeros)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.3 - Forward and Backward propagation\n", + "\n", + "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n", + "\n", + "\n", + "### Exercise 5 - propagate\n", + "Implement a function `propagate()` that computes the cost function and its gradient.\n", + "\n", + "**Hints**:\n", + "\n", + "Forward Propagation:\n", + "- You get X\n", + "- You compute $A = \\sigma(w^T X + b) = (a^{(1)}, a^{(2)}, ..., a^{(m-1)}, a^{(m)})$\n", + "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}(y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)}))$\n", + "\n", + "Here are the two formulas you will be using: \n", + "\n", + "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n", + "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "8552b2c9cff2b5fa537fab9f98a6e4da", + "grade": false, + "grade_id": "cell-11af17e28077b3d3", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: propagate\n", + "\n", + "def propagate(w, b, X, Y):\n", + " \"\"\"\n", + " Implement the cost function and its gradient for the propagation explained above\n", + "\n", + " Arguments:\n", + " w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n", + " b -- bias, a scalar\n", + " X -- data of size (num_px * num_px * 3, number of examples)\n", + " Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n", + "\n", + " Return:\n", + " grads -- dictionary containing the gradients of the weights and bias\n", + " (dw -- gradient of the loss with respect to w, thus same shape as w)\n", + " (db -- gradient of the loss with respect to b, thus same shape as b)\n", + " cost -- negative log-likelihood cost for logistic regression\n", + " \n", + " Tips:\n", + " - Write your code step by step for the propagation. np.log(), np.dot()\n", + " \"\"\"\n", + " \n", + " m = X.shape[1]\n", + " \n", + " # FORWARD PROPAGATION (FROM X TO COST)\n", + " #(≈ 2 lines of code)\n", + " # compute activation\n", + " # A = ...\n", + " # compute cost by using np.dot to perform multiplication. \n", + " # And don't use loops for the sum.\n", + " # cost = ... \n", + " # YOUR CODE STARTS HERE\n", + " Z=np.dot(w.T,X)+b\n", + " A=sigmoid(Z)\n", + "# A=1/(1+np.exp(-Z))\n", + " logA=np.log(A)\n", + " Atemp=np.log(1-A)\n", + " cost=-1/m*np.sum((np.multiply(Y,logA)+np.multiply(1-Y,Atemp)))\n", + " # YOUR CODE ENDS HERE\n", + "\n", + " # BACKWARD PROPAGATION (TO FIND GRAD)\n", + " #(≈ 2 lines of code)\n", + " # dw = ...\n", + " # db = ...\n", + " # YOUR CODE STARTS HERE\n", + "# print(\"A.shape\")\n", + "# print(Y.shape)\n", + " dZ=(A-Y)\n", + " dw=1/m*(np.dot(X,(dZ).T))\n", + " db=1/m*np.sum(dZ)\n", + " # YOUR CODE ENDS HERE\n", + " cost = np.squeeze(np.array(cost))\n", + "\n", + " \n", + " grads = {\"dw\": dw,\n", + " \"db\": db}\n", + " \n", + " return grads, cost" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b8a1a4b1ff8d70ac609d721490b4d826", + "grade": true, + "grade_id": "cell-d1594d75b61dd554", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dw = [[ 0.25071532]\n", + " [-0.06604096]]\n", + "db = -0.1250040450043965\n", + "cost = 0.15900537707692405\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "w = np.array([[1.], [2]])\n", + "b = 1.5\n", + "X = np.array([[1., -2., -1.], [3., 0.5, -3.2]])\n", + "Y = np.array([[1, 1, 0]])\n", + "grads, cost = propagate(w, b, X, Y)\n", + "\n", + "assert type(grads[\"dw\"]) == np.ndarray\n", + "assert grads[\"dw\"].shape == (2, 1)\n", + "assert type(grads[\"db\"]) == np.float64\n", + "\n", + "\n", + "print (\"dw = \" + str(grads[\"dw\"]))\n", + "print (\"db = \" + str(grads[\"db\"]))\n", + "print (\"cost = \" + str(cost))\n", + "\n", + "propagate_test(propagate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output**\n", + "\n", + "```\n", + "dw = [[ 0.25071532]\n", + " [-0.06604096]]\n", + "db = -0.1250040450043965\n", + "cost = 0.15900537707692405\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4 - Optimization\n", + "- You have initialized your parameters.\n", + "- You are also able to compute a cost function and its gradient.\n", + "- Now, you want to update the parameters using gradient descent.\n", + "\n", + "\n", + "### Exercise 6 - optimize\n", + "Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "49d9b4c1a780bf141c8eb48e06cbb494", + "grade": false, + "grade_id": "cell-616d6883e807448d", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: optimize\n", + "\n", + "def optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False):\n", + " \"\"\"\n", + " This function optimizes w and b by running a gradient descent algorithm\n", + " \n", + " Arguments:\n", + " w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n", + " b -- bias, a scalar\n", + " X -- data of shape (num_px * num_px * 3, number of examples)\n", + " Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n", + " num_iterations -- number of iterations of the optimization loop\n", + " learning_rate -- learning rate of the gradient descent update rule\n", + " print_cost -- True to print the loss every 100 steps\n", + " \n", + " Returns:\n", + " params -- dictionary containing the weights w and bias b\n", + " grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n", + " costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n", + " \n", + " Tips:\n", + " You basically need to write down two steps and iterate through them:\n", + " 1) Calculate the cost and the gradient for the current parameters. Use propagate().\n", + " 2) Update the parameters using gradient descent rule for w and b.\n", + " \"\"\"\n", + " \n", + " w = copy.deepcopy(w)\n", + " b = copy.deepcopy(b)\n", + " \n", + " costs = []\n", + " \n", + " for i in range(num_iterations):\n", + " # (≈ 1 lines of code)\n", + " # Cost and gradient calculation \n", + " # grads, cost = ...\n", + " # YOUR CODE STARTS HERE\n", + "# print(str(w.shape)+'w')\n", + "# print(str(X.shape)+'X')\n", + " grads, cost = propagate(w, b, X, Y)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Retrieve derivatives from grads\n", + " dw = grads[\"dw\"]\n", + " db = grads[\"db\"]\n", + " \n", + " # update rule (≈ 2 lines of code)\n", + " # w = ...\n", + " # b = ...\n", + " # YOUR CODE STARTS HERE\n", + " w=w-learning_rate*dw\n", + " b=b-learning_rate*db\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Record the costs\n", + " if i % 100 == 0:\n", + " costs.append(cost)\n", + " \n", + " # Print the cost every 100 training iterations\n", + " if print_cost:\n", + " print (\"Cost after iteration %i: %f\" %(i, cost))\n", + " \n", + " params = {\"w\": w,\n", + " \"b\": b}\n", + " \n", + " grads = {\"dw\": dw,\n", + " \"db\": db}\n", + " \n", + " return params, grads, costs" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b65a5c90f86a990614156e41f64b4678", + "grade": true, + "grade_id": "cell-8e3d43fbb82a8901", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w = [[0.80956046]\n", + " [2.0508202 ]]\n", + "b = 1.5948713189708588\n", + "dw = [[ 0.17860505]\n", + " [-0.04840656]]\n", + "db = -0.08888460336847771\n", + "Costs = [array(0.15900538)]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "params, grads, costs = optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False)\n", + "\n", + "print (\"w = \" + str(params[\"w\"]))\n", + "print (\"b = \" + str(params[\"b\"]))\n", + "print (\"dw = \" + str(grads[\"dw\"]))\n", + "print (\"db = \" + str(grads[\"db\"]))\n", + "print(\"Costs = \" + str(costs))\n", + "\n", + "optimize_test(optimize)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 7 - predict\n", + "The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There are two steps to computing predictions:\n", + "\n", + "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n", + "\n", + "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e56419b97ebf382a8f93ac2873988887", + "grade": false, + "grade_id": "cell-d6f924f49c51dc2f", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: predict\n", + "\n", + "def predict(w, b, X):\n", + " '''\n", + " Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n", + " \n", + " Arguments:\n", + " w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n", + " b -- bias, a scalar\n", + " X -- data of size (num_px * num_px * 3, number of examples)\n", + " \n", + " Returns:\n", + " Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n", + " '''\n", + " \n", + " m = X.shape[1]\n", + " Y_prediction = np.zeros((1, m))\n", + " w = w.reshape(X.shape[0], 1)\n", + " \n", + " # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n", + " #(≈ 1 line of code)\n", + " # A = ...\n", + " # YOUR CODE STARTS HERE\n", + " A=sigmoid(np.dot(w.T,X)+b)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + "# if(A>0.5):\n", + "# print('hello')\n", + " \n", + " for i in range(A.shape[1]):\n", + " \n", + " # Convert probabilities A[0,i] to actual predictions p[0,i]\n", + " #(≈ 4 lines of code)\n", + " if A[0, i] > 0.5 :\n", + " Y_prediction[0,i] = 1\n", + " else:\n", + " Y_prediction[0,i] = 0\n", + " # YOUR CODE STARTS HERE\n", + " \n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return Y_prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e3ea12608f15798d542a07c1bc9f561b", + "grade": true, + "grade_id": "cell-90b1fb967269548c", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predictions = [[1. 1. 0.]]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "w = np.array([[0.1124579], [0.23106775]])\n", + "b = -0.3\n", + "X = np.array([[1., -1.1, -3.2],[1.2, 2., 0.1]])\n", + "print (\"predictions = \" + str(predict(w, b, X)))\n", + "\n", + "predict_test(predict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + "**What to remember:**\n", + " \n", + "You've implemented several functions that:\n", + "- Initialize (w,b)\n", + "- Optimize the loss iteratively to learn parameters (w,b):\n", + " - Computing the cost and its gradient \n", + " - Updating the parameters using gradient descent\n", + "- Use the learned (w,b) to predict the labels for a given set of examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5 - Merge all functions into a model ##\n", + "\n", + "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n", + "\n", + "\n", + "### Exercise 8 - model\n", + "Implement the model function. Use the following notation:\n", + " - Y_prediction_test for your predictions on the test set\n", + " - Y_prediction_train for your predictions on the train set\n", + " - parameters, grads, costs for the outputs of optimize()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b62adfb8f5a0f5bb5aa6798c3c5df66d", + "grade": false, + "grade_id": "cell-6dcba5967c4cbf8c", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: model\n", + "\n", + "def model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):\n", + " \"\"\"\n", + " Builds the logistic regression model by calling the function you've implemented previously\n", + " \n", + " Arguments:\n", + " X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n", + " Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n", + " X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n", + " Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n", + " num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n", + " learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n", + " print_cost -- Set to True to print the cost every 100 iterations\n", + " \n", + " Returns:\n", + " d -- dictionary containing information about the model.\n", + " \"\"\"\n", + " # (≈ 1 line of code) \n", + " # initialize parameters with zeros\n", + " # and use the \"shape\" function to get the first dimension of X_train\n", + " # w, b = ...\n", + " \n", + " #(≈ 1 line of code)\n", + " # Gradient descent \n", + " # params, grads, costs = ...\n", + " \n", + " # Retrieve parameters w and b from dictionary \"params\"\n", + " # w = ...\n", + " # b = ...\n", + " \n", + " # Predict test/train set examples (≈ 2 lines of code)\n", + " # Y_prediction_test = ...\n", + " # Y_prediction_train = ...\n", + " \n", + " # YOUR CODE STARTS HERE\n", + " w,b=initialize_with_zeros(X_train.shape[0])\n", + " grads,costs= propagate(w, b, X_train, Y_train)\n", + " params,grads,cost1=optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n", + " w=params['w']\n", + " b=params['b']\n", + "\n", + " Y_prediction_train= predict(w, b, X_train)\n", + "# w,b=initialize_with_zeros(X_test.shape[0])\n", + "# grads,cost2= propagate(w, b, X_test, Y_test)\n", + "# params,grads,cost=optimize(w, b, X_test, Y_test, num_iterations, learning_rate, print_cost)\n", + " \n", + " Y_prediction_test= predict(w, b, X_test)\n", + " costs=[cost1]\n", + " # YOUR CODE ENDS HERE\n", + "\n", + " # Print train/test Errors\n", + " if print_cost:\n", + " print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n", + " print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n", + "\n", + " \n", + " d = {\"costs\": costs,\n", + " \"Y_prediction_test\": Y_prediction_test, \n", + " \"Y_prediction_train\" : Y_prediction_train, \n", + " \"w\" : w, \n", + " \"b\" : b,\n", + " \"learning_rate\" : learning_rate,\n", + " \"num_iterations\": num_iterations}\n", + " \n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b468bc5ddf6ecc5c7dbcb9a02cfe0216", + "grade": true, + "grade_id": "cell-4170e070f3cde17e", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "from public_tests import *\n", + "\n", + "model_test(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you pass all the tests, run the following cell to train your model." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost after iteration 0: 0.693147\n", + "Cost after iteration 100: 0.584508\n", + "Cost after iteration 200: 0.466949\n", + "Cost after iteration 300: 0.376007\n", + "Cost after iteration 400: 0.331463\n", + "Cost after iteration 500: 0.303273\n", + "Cost after iteration 600: 0.279880\n", + "Cost after iteration 700: 0.260042\n", + "Cost after iteration 800: 0.242941\n", + "Cost after iteration 900: 0.228004\n", + "Cost after iteration 1000: 0.214820\n", + "Cost after iteration 1100: 0.203078\n", + "Cost after iteration 1200: 0.192544\n", + "Cost after iteration 1300: 0.183033\n", + "Cost after iteration 1400: 0.174399\n", + "Cost after iteration 1500: 0.166521\n", + "Cost after iteration 1600: 0.159305\n", + "Cost after iteration 1700: 0.152667\n", + "Cost after iteration 1800: 0.146542\n", + "Cost after iteration 1900: 0.140872\n", + "train accuracy: 99.04306220095694 %\n", + "test accuracy: 70.0 %\n" + ] + } + ], + "source": [ + "logistic_regression_model = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=2000, learning_rate=0.005, print_cost=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test accuracy is 70%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n", + "\n", + "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = 1, you predicted that it is a \"cat\" picture.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Example of a picture that was wrongly classified.\n", + "index = 4\n", + "\n", + "plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3)))\n", + "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[int(logistic_regression_model['Y_prediction_test'][0,index])].decode(\"utf-8\") + \"\\\" picture.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's also plot the cost function and the gradients." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot learning curve (with costs)\n", + "costs = np.squeeze(logistic_regression_model['costs'])\n", + "plt.plot(costs)\n", + "plt.ylabel('cost')\n", + "plt.xlabel('iterations (per hundreds)')\n", + "plt.title(\"Learning rate =\" + str(logistic_regression_model[\"learning_rate\"]))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interpretation**:\n", + "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 6 - Further analysis (optional/ungraded exercise) ##\n", + "\n", + "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Choice of learning rate ####\n", + "\n", + "**Reminder**:\n", + "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$ determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n", + "\n", + "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training a model with learning rate: 0.01\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "Training a model with learning rate: 0.001\n" + ] + } + ], + "source": [ + "learning_rates = [0.01, 0.001, 0.0001]\n", + "models = {}\n", + "\n", + "for lr in learning_rates:\n", + " print (\"Training a model with learning rate: \" + str(lr))\n", + " models[str(lr)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=1500, learning_rate=lr, print_cost=False)\n", + " print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n", + "\n", + "for lr in learning_rates:\n", + " plt.plot(np.squeeze(models[str(lr)][\"costs\"]), label=str(models[str(lr)][\"learning_rate\"]))\n", + "\n", + "plt.ylabel('cost')\n", + "plt.xlabel('iterations (hundreds)')\n", + "\n", + "legend = plt.legend(loc='upper center', shadow=True)\n", + "frame = legend.get_frame()\n", + "frame.set_facecolor('0.90')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interpretation**: \n", + "- Different learning rates give different costs and thus different predictions results.\n", + "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n", + "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n", + "- In deep learning, we usually recommend that you: \n", + " - Choose the learning rate that better minimizes the cost function.\n", + " - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 7 - Test with your own image (optional/ungraded exercise) ##\n", + "\n", + "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n", + " 1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n", + " 2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n", + " 3. Change your image's name in the following code\n", + " 4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y = 1.0, your algorithm predicts a \"cat\" picture.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# change this to the name of your image file\n", + "my_image = \"bananacat1.jpg\" \n", + "\n", + "# We preprocess the image to fit your algorithm.\n", + "fname = my_image\n", + "image=np.array(Image.open(fname).resize((num_px, num_px)))\n", + "imageplot = np.array(Image.open(fname).resize((num_px*4, num_px*4)))\n", + "plt.imshow(imageplot)\n", + "image = image / 255.\n", + "image = image.reshape((1, num_px * num_px * 3)).T\n", + "my_predicted_image = predict(logistic_regression_model[\"w\"], logistic_regression_model[\"b\"], image)\n", + "\n", + "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") + \"\\\" picture.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + "**What to remember from this assignment:**\n", + "1. Preprocessing the dataset is important.\n", + "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n", + "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. Once you submit, things you can play with include:\n", + " - Play with the learning rate and the number of iterations\n", + " - Try different initialization methods and compare the results\n", + " - Test other preprocessings (center the data, or divide each row by its standard deviation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Bibliography:\n", + "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n", + "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Assignments/Planar_data_classification_with_one_hidden_layer.ipynb b/Assignments/Planar_data_classification_with_one_hidden_layer.ipynb new file mode 100644 index 0000000..8d8af00 --- /dev/null +++ b/Assignments/Planar_data_classification_with_one_hidden_layer.ipynb @@ -0,0 +1,67357 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Planar data classification with one hidden layer\n", + "\n", + "Welcome to your week 3 programming assignment! It's time to build your first neural network, which will have one hidden layer. Now, you'll notice a big difference between this model and the one you implemented previously using logistic regression.\n", + "\n", + "By the end of this assignment, you'll be able to:\n", + "\n", + "- Implement a 2-class classification neural network with a single hidden layer\n", + "- Use units with a non-linear activation function, such as tanh\n", + "- Compute the cross entropy loss\n", + "- Implement forward and backward propagation\n", + "\n", + "## Important Note on Submission to the AutoGrader\n", + "\n", + "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n", + "\n", + "1. You have not added any _extra_ `print` statement(s) in the assignment.\n", + "2. You have not added any _extra_ code cell(s) in the assignment.\n", + "3. You have not changed any of the function parameters.\n", + "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n", + "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n", + "\n", + "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/neural-networks-deep-learning/supplement/iLwon/h-ow-to-refresh-your-workspace)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "- [1 - Packages](#1)\n", + "- [2 - Load the Dataset](#2)\n", + " - [Exercise 1](#ex-1)\n", + "- [3 - Simple Logistic Regression](#3)\n", + "- [4 - Neural Network model](#4)\n", + " - [4.1 - Defining the neural network structure](#4-1)\n", + " - [Exercise 2 - layer_sizes](#ex-2)\n", + " - [4.2 - Initialize the model's parameters](#4-2)\n", + " - [Exercise 3 - initialize_parameters](#ex-3)\n", + " - [4.3 - The Loop](#4-3)\n", + " - [Exercise 4 - forward_propagation](#ex-4)\n", + " - [4.4 - Compute the Cost](#4-4)\n", + " - [Exercise 5 - compute_cost](#ex-5)\n", + " - [4.5 - Implement Backpropagation](#4-5)\n", + " - [Exercise 6 - backward_propagation](#ex-6)\n", + " - [4.6 - Update Parameters](#4-6)\n", + " - [Exercise 7 - update_parameters](#ex-7)\n", + " - [4.7 - Integration](#4-7)\n", + " - [Exercise 8 - nn_model](#ex-8)\n", + "- [5 - Test the Model](#5)\n", + " - [5.1 - Predict](#5-1)\n", + " - [Exercise 9 - predict](#ex-9)\n", + " - [5.2 - Test the Model on the Planar Dataset](#5-2)\n", + "- [6 - Tuning hidden layer size (optional/ungraded exercise)](#6)\n", + "- [7- Performance on other datasets](#7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 1 - Packages\n", + "\n", + "First import all the packages that you will need during this assignment.\n", + "\n", + "- [numpy](https://www.numpy.org/) is the fundamental package for scientific computing with Python.\n", + "- [sklearn](http://scikit-learn.org/stable/) provides simple and efficient tools for data mining and data analysis. \n", + "- [matplotlib](http://matplotlib.org) is a library for plotting graphs in Python.\n", + "- testCases provides some test examples to assess the correctness of your functions\n", + "- planar_utils provide various useful functions used in this assignment" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Package imports\n", + "import numpy as np\n", + "import copy\n", + "import matplotlib.pyplot as plt\n", + "from testCases_v2 import *\n", + "from public_tests import *\n", + "import sklearn\n", + "import sklearn.datasets\n", + "import sklearn.linear_model\n", + "from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets\n", + "\n", + "%matplotlib inline\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 2 - Load the Dataset \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X, Y = load_planar_dataset()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the dataset using matplotlib. The data looks like a \"flower\" with some red (label y=0) and some blue (y=1) points. Your goal is to build a model to fit this data. In other words, we want the classifier to define regions as either red or blue." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the data:\n", + "plt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You have:\n", + " - a numpy-array (matrix) X that contains your features (x1, x2)\n", + " - a numpy-array (vector) Y that contains your labels (red:0, blue:1).\n", + "\n", + "First, get a better sense of what your data is like. \n", + "\n", + "\n", + "### Exercise 1 \n", + "\n", + "How many training examples do you have? In addition, what is the `shape` of the variables `X` and `Y`? \n", + "\n", + "**Hint**: How do you get the shape of a numpy array? [(help)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "d19673d5fa7f72081dde6ac5ebef8373", + "grade": false, + "grade_id": "cell-da23a484a9233d5c", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The shape of X is: (2, 400)\n", + "The shape of Y is: (1, 400)\n", + "I have m = 400 training examples!\n" + ] + } + ], + "source": [ + "# (≈ 3 lines of code)\n", + "# shape_X = ...\n", + "# shape_Y = ...\n", + "# training set size\n", + "# m = ...\n", + "# YOUR CODE STARTS HERE\n", + "shape_X=X.shape\n", + "# print(shape_X)\n", + "m=shape_X[1]\n", + "shape_Y=Y.shape\n", + "# print(shape_Y)\n", + "\n", + "\n", + "# YOUR CODE ENDS HERE\n", + "\n", + "print ('The shape of X is: ' + str(shape_X))\n", + "print ('The shape of Y is: ' + str(shape_Y))\n", + "print ('I have m = %d training examples!' % (m))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
shape of X (2, 400)
shape of Y(1, 400)
m 400
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3 - Simple Logistic Regression\n", + "\n", + "Before building a full neural network, let's check how logistic regression performs on this problem. You can use sklearn's built-in functions for this. Run the code below to train a logistic regression classifier on the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Train the logistic regression classifier\n", + "clf = sklearn.linear_model.LogisticRegressionCV();\n", + "clf.fit(X.T, Y.T);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can now plot the decision boundary of these models! Run the code below." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of logistic regression: 47 % (percentage of correctly labelled datapoints)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the decision boundary for logistic regression\n", + "plot_decision_boundary(lambda x: clf.predict(x), X, Y)\n", + "plt.title(\"Logistic Regression\")\n", + "\n", + "# Print accuracy\n", + "LR_predictions = clf.predict(X.T)\n", + "print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) +\n", + " '% ' + \"(percentage of correctly labelled datapoints)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**:\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Accuracy 47%
\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interpretation**: The dataset is not linearly separable, so logistic regression doesn't perform well. Hopefully a neural network will do better. Let's try this now! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4 - Neural Network model\n", + "\n", + "Logistic regression didn't work well on the flower dataset. Next, you're going to train a Neural Network with a single hidden layer and see how that handles the same problem.\n", + "\n", + "**The model**:\n", + "\n", + "\n", + "**Mathematically**:\n", + "\n", + "For one example $x^{(i)}$:\n", + "$$z^{[1] (i)} = W^{[1]} x^{(i)} + b^{[1]}\\tag{1}$$ \n", + "$$a^{[1] (i)} = \\tanh(z^{[1] (i)})\\tag{2}$$\n", + "$$z^{[2] (i)} = W^{[2]} a^{[1] (i)} + b^{[2]}\\tag{3}$$\n", + "$$\\hat{y}^{(i)} = a^{[2] (i)} = \\sigma(z^{ [2] (i)})\\tag{4}$$\n", + "$$y^{(i)}_{prediction} = \\begin{cases} 1 & \\mbox{if } a^{[2](i)} > 0.5 \\\\ 0 & \\mbox{otherwise } \\end{cases}\\tag{5}$$\n", + "\n", + "Given the predictions on all the examples, you can also compute the cost $J$ as follows: \n", + "$$J = - \\frac{1}{m} \\sum\\limits_{i = 0}^{m} \\large\\left(\\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right) \\large \\right) \\small \\tag{6}$$\n", + "\n", + "**Reminder**: The general methodology to build a Neural Network is to:\n", + " 1. Define the neural network structure ( # of input units, # of hidden units, etc). \n", + " 2. Initialize the model's parameters\n", + " 3. Loop:\n", + " - Implement forward propagation\n", + " - Compute loss\n", + " - Implement backward propagation to get the gradients\n", + " - Update parameters (gradient descent)\n", + "\n", + "In practice, you'll often build helper functions to compute steps 1-3, then merge them into one function called `nn_model()`. Once you've built `nn_model()` and learned the right parameters, you can make predictions on new data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.1 - Defining the neural network structure ####\n", + "\n", + "\n", + "### Exercise 2 - layer_sizes \n", + "\n", + "Define three variables:\n", + "- n_x: the size of the input layer\n", + "- n_h: the size of the hidden layer (**set this to 4, as `n_h = 4`, but only for this Exercise 2**) \n", + "- n_y: the size of the output layer\n", + "\n", + "**Hint**: Use shapes of X and Y to find n_x and n_y. Also, hard code the hidden layer size to be 4." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "40a4061cd6df43988d25ebea254e3a3b", + "grade": false, + "grade_id": "cell-bf6ef9d827b48201", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: layer_sizes\n", + "\n", + "def layer_sizes(X, Y):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- input dataset of shape (input size, number of examples)\n", + " Y -- labels of shape (output size, number of examples)\n", + " \n", + " Returns:\n", + " n_x -- the size of the input layer\n", + " n_h -- the size of the hidden layer\n", + " n_y -- the size of the output layer\n", + " \"\"\"\n", + " #(≈ 3 lines of code)\n", + " # n_x = ... \n", + " # n_h = ...\n", + " # n_y = ... \n", + " # YOUR CODE STARTS HERE\n", + " n_x=X.shape[0]\n", + "# print(Y.shape)\n", + " n_h=4\n", + " n_y=Y.shape[0]\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " return (n_x, n_h, n_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "314281d8cdb343ad6fc836d2f68ddc84", + "grade": true, + "grade_id": "cell-c98fce5b0806c953", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The size of the input layer is: n_x = 5\n", + "The size of the hidden layer is: n_h = 4\n", + "The size of the output layer is: n_y = 2\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "t_X, t_Y = layer_sizes_test_case()\n", + "(n_x, n_h, n_y) = layer_sizes(t_X, t_Y)\n", + "print(\"The size of the input layer is: n_x = \" + str(n_x))\n", + "print(\"The size of the hidden layer is: n_h = \" + str(n_h))\n", + "print(\"The size of the output layer is: n_y = \" + str(n_y))\n", + "\n", + "layer_sizes_test(layer_sizes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "The size of the input layer is: n_x = 5\n", + "The size of the hidden layer is: n_h = 4\n", + "The size of the output layer is: n_y = 2\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.2 - Initialize the model's parameters ####\n", + "\n", + "\n", + "### Exercise 3 - initialize_parameters\n", + "\n", + "Implement the function `initialize_parameters()`.\n", + "\n", + "**Instructions**:\n", + "- Make sure your parameters' sizes are right. Refer to the neural network figure above if needed.\n", + "- You will initialize the weights matrices with random values. \n", + " - Use: `np.random.randn(a,b) * 0.01` to randomly initialize a matrix of shape (a,b).\n", + "- You will initialize the bias vectors as zeros. \n", + " - Use: `np.zeros((a,b))` to initialize a matrix of shape (a,b) with zeros." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "09cf806395560c43e4a130688bae9096", + "grade": false, + "grade_id": "cell-e701a137e4b826ea", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: initialize_parameters\n", + "\n", + "def initialize_parameters(n_x, n_h, n_y):\n", + " \"\"\"\n", + " Argument:\n", + " n_x -- size of the input layer\n", + " n_h -- size of the hidden layer\n", + " n_y -- size of the output layer\n", + " \n", + " Returns:\n", + " params -- python dictionary containing your parameters:\n", + " W1 -- weight matrix of shape (n_h, n_x)\n", + " b1 -- bias vector of shape (n_h, 1)\n", + " W2 -- weight matrix of shape (n_y, n_h)\n", + " b2 -- bias vector of shape (n_y, 1)\n", + " \"\"\" \n", + " #(≈ 4 lines of code)\n", + " # W1 = ...\n", + " # b1 = ...\n", + " # W2 = ...\n", + " # b2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1=np.random.randn(n_h,n_x)*0.01\n", + " b1=np.zeros((n_h,1))\n", + " W2=np.random.randn(n_y,n_h)*0.01\n", + " b2=np.zeros((n_y,1))\n", + " \n", + " # YOUR CODE ENDS HERE\n", + "\n", + " parameters = {\"W1\": W1,\n", + " \"b1\": b1,\n", + " \"W2\": W2,\n", + " \"b2\": b2}\n", + " \n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "045cf9c8734315fb006b39700c252b85", + "grade": true, + "grade_id": "cell-7aa275067ab508e9", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 = [[-0.00416758 -0.00056267]\n", + " [-0.02136196 0.01640271]\n", + " [-0.01793436 -0.00841747]\n", + " [ 0.00502881 -0.01245288]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.01057952 -0.00909008 0.00551454 0.02292208]]\n", + "b2 = [[0.]]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "np.random.seed(2)\n", + "n_x, n_h, n_y = initialize_parameters_test_case()\n", + "parameters = initialize_parameters(n_x, n_h, n_y)\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "initialize_parameters_test(initialize_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output**\n", + "```\n", + "W1 = [[-0.00416758 -0.00056267]\n", + " [-0.02136196 0.01640271]\n", + " [-0.01793436 -0.00841747]\n", + " [ 0.00502881 -0.01245288]]\n", + "b1 = [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "W2 = [[-0.01057952 -0.00909008 0.00551454 0.02292208]]\n", + "b2 = [[0.]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.3 - The Loop \n", + "\n", + "\n", + "### Exercise 4 - forward_propagation\n", + "\n", + "Implement `forward_propagation()` using the following equations:\n", + "\n", + "$$Z^{[1]} = W^{[1]} X + b^{[1]}\\tag{1}$$ \n", + "$$A^{[1]} = \\tanh(Z^{[1]})\\tag{2}$$\n", + "$$Z^{[2]} = W^{[2]} A^{[1]} + b^{[2]}\\tag{3}$$\n", + "$$\\hat{Y} = A^{[2]} = \\sigma(Z^{[2]})\\tag{4}$$\n", + "\n", + "\n", + "**Instructions**:\n", + "\n", + "- Check the mathematical representation of your classifier in the figure above.\n", + "- Use the function `sigmoid()`. It's built into (imported) this notebook.\n", + "- Use the function `np.tanh()`. It's part of the numpy library.\n", + "- Implement using these steps:\n", + " 1. Retrieve each parameter from the dictionary \"parameters\" (which is the output of `initialize_parameters()` by using `parameters[\"..\"]`.\n", + " 2. Implement Forward Propagation. Compute $Z^{[1]}, A^{[1]}, Z^{[2]}$ and $A^{[2]}$ (the vector of all your predictions on all the examples in the training set).\n", + "- Values needed in the backpropagation are stored in \"cache\". The cache will be given as an input to the backpropagation function." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "f85c43256805578b8386a15d778dfd6a", + "grade": false, + "grade_id": "cell-b41d8713ffbb054c", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION:forward_propagation\n", + "\n", + "def forward_propagation(X, parameters):\n", + " \"\"\"\n", + " Argument:\n", + " X -- input data of size (n_x, m)\n", + " parameters -- python dictionary containing your parameters (output of initialization function)\n", + " \n", + " Returns:\n", + " A2 -- The sigmoid output of the second activation\n", + " cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\"\n", + " \"\"\"\n", + " # Retrieve each parameter from the dictionary \"parameters\"\n", + " #(≈ 4 lines of code)\n", + " # W1 = ...\n", + " # b1 = ...\n", + " # W2 = ...\n", + " # b2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1=parameters['W1']\n", + " b1=parameters['b1']\n", + " W2=parameters['W2']\n", + " b2=parameters['b2']\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Implement Forward Propagation to calculate A2 (probabilities)\n", + " # (≈ 4 lines of code)\n", + " # Z1 = ...\n", + " # A1 = ...\n", + " # Z2 = ...\n", + " # A2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " Z1= np.dot(W1,X)+b1\n", + " A1= np.tanh(Z1)\n", + " Z2= np.dot(W2,A1)+b2\n", + " A2= sigmoid(Z2)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " assert(A2.shape == (1, X.shape[1]))\n", + " \n", + " cache = {\"Z1\": Z1,\n", + " \"A1\": A1,\n", + " \"Z2\": Z2,\n", + " \"A2\": A2}\n", + " \n", + " return A2, cache" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "8742f1f4bedcdb56dcc2a15bb794ff79", + "grade": true, + "grade_id": "cell-8c8104df1945b472", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A2 = [[0.21292656 0.21274673 0.21295976]]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "t_X, parameters = forward_propagation_test_case()\n", + "A2, cache = forward_propagation(t_X, parameters)\n", + "print(\"A2 = \" + str(A2))\n", + "\n", + "forward_propagation_test(forward_propagation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "A2 = [[0.21292656 0.21274673 0.21295976]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4 - Compute the Cost\n", + "\n", + "Now that you've computed $A^{[2]}$ (in the Python variable \"`A2`\"), which contains $a^{[2](i)}$ for all examples, you can compute the cost function as follows:\n", + "\n", + "$$J = - \\frac{1}{m} \\sum\\limits_{i = 1}^{m} \\large{(} \\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right) \\large{)} \\small\\tag{13}$$\n", + "\n", + "\n", + "### Exercise 5 - compute_cost \n", + "\n", + "Implement `compute_cost()` to compute the value of the cost $J$.\n", + "\n", + "**Instructions**:\n", + "- There are many ways to implement the cross-entropy loss. This is one way to implement one part of the equation without for loops:\n", + "$- \\sum\\limits_{i=1}^{m} y^{(i)}\\log(a^{[2](i)})$:\n", + "```python\n", + "logprobs = np.multiply(np.log(A2),Y)\n", + "cost = - np.sum(logprobs) \n", + "```\n", + "\n", + "- Use that to build the whole expression of the cost function.\n", + "\n", + "**Notes**: \n", + "\n", + "- You can use either `np.multiply()` and then `np.sum()` or directly `np.dot()`). \n", + "- If you use `np.multiply` followed by `np.sum` the end result will be a type `float`, whereas if you use `np.dot`, the result will be a 2D numpy array. \n", + "- You can use `np.squeeze()` to remove redundant dimensions (in the case of single float, this will be reduced to a zero-dimension array). \n", + "- You can also cast the array as a type `float` using `float()`." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "40359ee771bdf2b1c9306b2d03fc975f", + "grade": false, + "grade_id": "cell-3dba3a966f90c35a", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: compute_cost\n", + "\n", + "def compute_cost(A2, Y):\n", + " \"\"\"\n", + " Computes the cross-entropy cost given in equation (13)\n", + " \n", + " Arguments:\n", + " A2 -- The sigmoid output of the second activation, of shape (1, number of examples)\n", + " Y -- \"true\" labels vector of shape (1, number of examples)\n", + "\n", + " Returns:\n", + " cost -- cross-entropy cost given equation (13)\n", + " \n", + " \"\"\"\n", + " \n", + " m = Y.shape[1] # number of examples\n", + "\n", + " # Compute the cross-entropy cost\n", + " # (≈ 2 lines of code)\n", + " # logprobs = ...\n", + " # cost = ...\n", + " # YOUR CODE STARTS HERE\n", + " logprobs=np.multiply(np.log(A2),Y)+np.multiply(1-Y,np.log(1-A2))\n", + " cost=-1/m*(np.sum(logprobs))\n", + "# print(str(cost.shape)+'costshape')\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect. \n", + " # E.g., turns [[17]] into 17 \n", + " \n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "237213dfd4d9da35e08c7477d5fddd12", + "grade": true, + "grade_id": "cell-be9a6c2220f20d3a", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cost = 0.6930587610394646\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "A2, t_Y = compute_cost_test_case()\n", + "cost = compute_cost(A2, t_Y)\n", + "print(\"cost = \" + str(compute_cost(A2, t_Y)))\n", + "\n", + "compute_cost_test(compute_cost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "cost = 0.6930587610394646\n", + "All tests passed!\n", + "``` \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.5 - Implement Backpropagation\n", + "\n", + "Using the cache computed during forward propagation, you can now implement backward propagation.\n", + "\n", + "\n", + "### Exercise 6 - backward_propagation\n", + "\n", + "Implement the function `backward_propagation()`.\n", + "\n", + "**Instructions**:\n", + "Backpropagation is usually the hardest (most mathematical) part in deep learning. To help you, here again is the slide from the lecture on backpropagation. You'll want to use the six equations on the right of this slide, since you are building a vectorized implementation. \n", + "\n", + "\n", + "
Figure 1: Backpropagation. Use the six equations on the right.
\n", + "\n", + "\n", + "\n", + "- Tips:\n", + " - To compute dZ1 you'll need to compute $g^{[1]'}(Z^{[1]})$. Since $g^{[1]}(.)$ is the tanh activation function, if $a = g^{[1]}(z)$ then $g^{[1]'}(z) = 1-a^2$. So you can compute \n", + " $g^{[1]'}(Z^{[1]})$ using `(1 - np.power(A1, 2))`." + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "b3e942b09120df109c1602281e11576b", + "grade": false, + "grade_id": "cell-0f8a26305f1ccef7", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: backward_propagation\n", + "\n", + "def backward_propagation(parameters, cache, X, Y):\n", + " \"\"\"\n", + " Implement the backward propagation using the instructions above.\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing our parameters \n", + " cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\".\n", + " X -- input data of shape (2, number of examples)\n", + " Y -- \"true\" labels vector of shape (1, number of examples)\n", + " \n", + " Returns:\n", + " grads -- python dictionary containing your gradients with respect to different parameters\n", + " \"\"\"\n", + " m = X.shape[1]\n", + " print(X.shape)\n", + " \n", + " # First, retrieve W1 and W2 from the dictionary \"parameters\".\n", + " #(≈ 2 lines of code)\n", + " # W1 = ...\n", + " # W2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1= parameters['W1']\n", + " W2= parameters['W2']\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Retrieve also A1 and A2 from dictionary \"cache\".\n", + " #(≈ 2 lines of code)\n", + " # A1 = ...\n", + " # A2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " A1=cache['A1']\n", + " A2=cache['A2']\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Backward propagation: calculate dW1, db1, dW2, db2. \n", + " #(≈ 6 lines of code, corresponding to 6 equations on slide above)\n", + " # dZ2 = ...\n", + " # dW2 = ...\n", + " # db2 = ...\n", + " # dZ1 = ...\n", + " # dW1 = ...\n", + " # db1 = ...\n", + " # YOUR CODE STARTS HERE\n", + " dZ2=A2-Y\n", + " dW2=1/m*np.dot(dZ2,A1.T)\n", + " db2=1/m*np.sum(dZ2,axis=1,keepdims=True)\n", + " dZ1=np.dot(W2.T,dZ2)*(1-np.power(A1,2))\n", + " dW1=1/m*np.dot(dZ1,X.T)\n", + " db1=1/m*np.sum(dZ1,axis=1,keepdims=True)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " grads = {\"dW1\": dW1,\n", + " \"db1\": db1,\n", + " \"dW2\": dW2,\n", + " \"db2\": db2}\n", + " \n", + " return grads" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "d7083c449c3dd88f91128e1c5d4d80c7", + "grade": true, + "grade_id": "cell-cbd08e4138b79fe9", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3)\n", + "dW1 = [[ 0.00301023 -0.00747267]\n", + " [ 0.00257968 -0.00641288]\n", + " [-0.00156892 0.003893 ]\n", + " [-0.00652037 0.01618243]]\n", + "db1 = [[ 0.00176201]\n", + " [ 0.00150995]\n", + " [-0.00091736]\n", + " [-0.00381422]]\n", + "dW2 = [[ 0.00078841 0.01765429 -0.00084166 -0.01022527]]\n", + "db2 = [[-0.16655712]]\n", + "(3, 7)\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "parameters, cache, t_X, t_Y = backward_propagation_test_case()\n", + "\n", + "grads = backward_propagation(parameters, cache, t_X, t_Y)\n", + "print (\"dW1 = \"+ str(grads[\"dW1\"]))\n", + "print (\"db1 = \"+ str(grads[\"db1\"]))\n", + "print (\"dW2 = \"+ str(grads[\"dW2\"]))\n", + "print (\"db2 = \"+ str(grads[\"db2\"]))\n", + "\n", + "backward_propagation_test(backward_propagation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "dW1 = [[ 0.00301023 -0.00747267]\n", + " [ 0.00257968 -0.00641288]\n", + " [-0.00156892 0.003893 ]\n", + " [-0.00652037 0.01618243]]\n", + "db1 = [[ 0.00176201]\n", + " [ 0.00150995]\n", + " [-0.00091736]\n", + " [-0.00381422]]\n", + "dW2 = [[ 0.00078841 0.01765429 -0.00084166 -0.01022527]]\n", + "db2 = [[-0.16655712]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.6 - Update Parameters \n", + "\n", + "\n", + "### Exercise 7 - update_parameters\n", + "\n", + "Implement the update rule. Use gradient descent. You have to use (dW1, db1, dW2, db2) in order to update (W1, b1, W2, b2).\n", + "\n", + "**General gradient descent rule**: $\\theta = \\theta - \\alpha \\frac{\\partial J }{ \\partial \\theta }$ where $\\alpha$ is the learning rate and $\\theta$ represents a parameter.\n", + "\n", + " \n", + "
Figure 2: The gradient descent algorithm with a good learning rate (converging) and a bad learning rate (diverging). Images courtesy of Adam Harley.
\n", + "\n", + "**Hint**\n", + "\n", + "- Use `copy.deepcopy(...)` when copying lists or dictionaries that are passed as parameters to functions. It avoids input parameters being modified within the function. In some scenarios, this could be inefficient, but it is required for grading purposes.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "63f89f94a280c8674c7ece8f915fb051", + "grade": false, + "grade_id": "cell-f0a3d6f05b55f29e", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: update_parameters\n", + "\n", + "def update_parameters(parameters, grads, learning_rate = 1.2):\n", + " \"\"\"\n", + " Updates parameters using the gradient descent update rule given above\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing your parameters \n", + " grads -- python dictionary containing your gradients \n", + " \n", + " Returns:\n", + " parameters -- python dictionary containing your updated parameters \n", + " \"\"\"\n", + " # Retrieve a copy of each parameter from the dictionary \"parameters\". Use copy.deepcopy(...) for W1 and W2\n", + " #(≈ 4 lines of code)\n", + " # W1 = ...\n", + " # b1 = ...\n", + " # W2 = ...\n", + " # b2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1=copy.deepcopy(parameters['W1'])\n", + " b1=copy.deepcopy(parameters['b1'])\n", + " W2=copy.deepcopy(parameters['W2'])\n", + " b2=copy.deepcopy(parameters['b2'])\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Retrieve each gradient from the dictionary \"grads\"\n", + " #(≈ 4 lines of code)\n", + " # dW1 = ...\n", + " # db1 = ...\n", + " # dW2 = ...\n", + " # db2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " dW1=copy.deepcopy(grads['dW1'])\n", + " db1=copy.deepcopy(grads['db1'])\n", + " dW2=copy.deepcopy(grads['dW2'])\n", + " db2=copy.deepcopy(grads['db2'])\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Update rule for each parameter\n", + " #(≈ 4 lines of code)\n", + " # W1 = ...\n", + " # b1 = ...\n", + " # W2 = ...\n", + " # b2 = ...\n", + " # YOUR CODE STARTS HERE\n", + " W1=W1-learning_rate*dW1\n", + " b1=b1-learning_rate*db1\n", + " W2=W2-learning_rate*dW2\n", + " b2=b2-learning_rate*db2\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " parameters = {\"W1\": W1,\n", + " \"b1\": b1,\n", + " \"W2\": W2,\n", + " \"b2\": b2}\n", + " \n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "0979d8e5e535620971e081abfff45839", + "grade": true, + "grade_id": "cell-21bc2649c66c1c26", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 = [[-0.00643025 0.01936718]\n", + " [-0.02410458 0.03978052]\n", + " [-0.01653973 -0.02096177]\n", + " [ 0.01046864 -0.05990141]]\n", + "b1 = [[-1.02420756e-06]\n", + " [ 1.27373948e-05]\n", + " [ 8.32996807e-07]\n", + " [-3.20136836e-06]]\n", + "W2 = [[-0.01041081 -0.04463285 0.01758031 0.04747113]]\n", + "b2 = [[0.00010457]]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "parameters, grads = update_parameters_test_case()\n", + "parameters = update_parameters(parameters, grads)\n", + "\n", + "print(\"W1 = \" + str(parameters[\"W1\"]))\n", + "print(\"b1 = \" + str(parameters[\"b1\"]))\n", + "print(\"W2 = \" + str(parameters[\"W2\"]))\n", + "print(\"b2 = \" + str(parameters[\"b2\"]))\n", + "\n", + "update_parameters_test(update_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "W1 = [[-0.00643025 0.01936718]\n", + " [-0.02410458 0.03978052]\n", + " [-0.01653973 -0.02096177]\n", + " [ 0.01046864 -0.05990141]]\n", + "b1 = [[-1.02420756e-06]\n", + " [ 1.27373948e-05]\n", + " [ 8.32996807e-07]\n", + " [-3.20136836e-06]]\n", + "W2 = [[-0.01041081 -0.04463285 0.01758031 0.04747113]]\n", + "b2 = [[0.00010457]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.7 - Integration\n", + "\n", + "Integrate your functions in `nn_model()` \n", + "\n", + "\n", + "### Exercise 8 - nn_model\n", + "\n", + "Build your neural network model in `nn_model()`.\n", + "\n", + "**Instructions**: The neural network model has to use the previous functions in the right order." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "461c83f5d15193186d8b122d0a451895", + "grade": false, + "grade_id": "cell-25f5e3e9b4ef006f", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: nn_model\n", + "\n", + "def nn_model(X, Y, n_h, num_iterations = 10000, print_cost=True):\n", + " \"\"\"\n", + " Arguments:\n", + " X -- dataset of shape (2, number of examples)\n", + " Y -- labels of shape (1, number of examples)\n", + " n_h -- size of the hidden layer\n", + " num_iterations -- Number of iterations in gradient descent loop\n", + " print_cost -- if True, print the cost every 1000 iterations\n", + " \n", + " Returns:\n", + " parameters -- parameters learnt by the model. They can then be used to predict.\n", + " \"\"\"\n", + " \n", + " np.random.seed(3)\n", + " n_x = layer_sizes(X, Y)[0]\n", + " n_y = layer_sizes(X, Y)[2]\n", + "# print(layer_sizes(X, Y))\n", + " # Initialize parameters\n", + " #(≈ 1 line of code)\n", + " # parameters = ...\n", + " # YOUR CODE STARTS HERE\n", + " parameters= initialize_parameters(n_x, n_h, n_y)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Loop (gradient descent)\n", + "\n", + " for i in range(0, num_iterations):\n", + " \n", + " #(≈ 4 lines of code)\n", + " # Forward propagation. Inputs: \"X, parameters\". Outputs: \"A2, cache\".\n", + " # A2, cache = ...\n", + " \n", + " # Cost function. Inputs: \"A2, Y\". Outputs: \"cost\".\n", + " # cost = ...\n", + " \n", + " # Backpropagation. Inputs: \"parameters, cache, X, Y\". Outputs: \"grads\".\n", + " # grads = ...\n", + " \n", + " # Gradient descent parameter update. Inputs: \"parameters, grads\". Outputs: \"parameters\".\n", + " # parameters = ...\n", + " \n", + " # YOUR CODE STARTS HERE\n", + " A2,cache=forward_propagation(X, parameters)\n", + " cost=compute_cost(A2, Y)\n", + " grads=backward_propagation(parameters,cache,X,Y)\n", + " parameters=update_parameters(parameters, grads, learning_rate=1.2)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " # Print the cost every 1000 iterations\n", + " if print_cost and i % 1000 == 0:\n", + " print (\"Cost after iteration %i: %f\" %(i, cost))\n", + "\n", + " return parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "c5a88642effdc073e396131eecc242b2", + "grade": true, + "grade_id": "cell-3484cc5d41a6cff7", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 4)\n", + "Cost after iteration 0: 0.693086\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 1000: 0.000220\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 2000: 0.000108\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 3000: 0.000072\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 4000: 0.000054\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 5000: 0.000043\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 6000: 0.000036\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 7000: 0.000030\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 8000: 0.000027\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "Cost after iteration 9000: 0.000024\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "W1 = [[ 0.71392202 1.31281102]\n", + " [-0.76411243 -1.41967065]\n", + " [-0.75040545 -1.38857337]\n", + " [ 0.56495575 1.04857776]]\n", + "b1 = [[-0.0073536 ]\n", + " [ 0.01534663]\n", + " [ 0.01262938]\n", + " [ 0.00218135]]\n", + "W2 = [[ 2.82545815 -3.3063945 -3.16116615 1.8549574 ]]\n", + "b2 = [[0.00393452]]\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "(2, 4)\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "nn_model_test(nn_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "Cost after iteration 0: 0.693198\n", + "Cost after iteration 1000: 0.000219\n", + "Cost after iteration 2000: 0.000108\n", + "...\n", + "Cost after iteration 8000: 0.000027\n", + "Cost after iteration 9000: 0.000024\n", + "W1 = [[ 0.71392202 1.31281102]\n", + " [-0.76411243 -1.41967065]\n", + " [-0.75040545 -1.38857337]\n", + " [ 0.56495575 1.04857776]]\n", + "b1 = [[-0.0073536 ]\n", + " [ 0.01534663]\n", + " [ 0.01262938]\n", + " [ 0.00218135]]\n", + "W2 = [[ 2.82545815 -3.3063945 -3.16116615 1.8549574 ]]\n", + "b2 = [[0.00393452]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5 - Test the Model\n", + "\n", + "\n", + "### 5.1 - Predict\n", + "\n", + "\n", + "### Exercise 9 - predict\n", + "\n", + "Predict with your model by building `predict()`.\n", + "Use forward propagation to predict results.\n", + "\n", + "**Reminder**: predictions = $y_{prediction} = \\mathbb 1 \\text{{activation > 0.5}} = \\begin{cases}\n", + " 1 & \\text{if}\\ activation > 0.5 \\\\\n", + " 0 & \\text{otherwise}\n", + " \\end{cases}$ \n", + " \n", + "As an example, if you would like to set the entries of a matrix X to 0 and 1 based on a threshold you would do: ```X_new = (X > threshold)```" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "47f6c9deeb2c83107018f17aa987bfe2", + "grade": false, + "grade_id": "cell-54e92a8c3c22758b", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: predict\n", + "\n", + "def predict(parameters, X):\n", + " \"\"\"\n", + " Using the learned parameters, predicts a class for each example in X\n", + " \n", + " Arguments:\n", + " parameters -- python dictionary containing your parameters \n", + " X -- input data of size (n_x, m)\n", + " \n", + " Returns\n", + " predictions -- vector of predictions of our model (red: 0 / blue: 1)\n", + " \"\"\"\n", + " \n", + " # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.\n", + " #(≈ 2 lines of code)\n", + " # A2, cache = ...\n", + " # predictions = ...\n", + " # YOUR CODE STARTS HERE\n", + " A2,cache=forward_propagation(X,parameters)\n", + " print(A2)\n", + " predictions=np.zeros((1,A2.shape[1]))\n", + " for i in range(A2.shape[1]):\n", + "# print(A2[i])\n", + " if A2[0,i]>0.5:\n", + " predictions[0,i]=1\n", + " else:\n", + " predictions[0,i]=0\n", + " # YOUR CODE ENDS HERE\n", + " return predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "930eb713dd8c9c0c38684deda0c4da0c", + "grade": true, + "grade_id": "cell-7d5ddc5f94da1d7a", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.50154066 0.49899566 0.50213783]]\n", + "[[1. 0. 1.]]\n", + "Predictions: [[1. 0. 1.]]\n", + "[[0.50154066 0.49899566 0.50213783]]\n", + "[[1. 0. 1.]]\n", + "\u001b[92mAll tests passed!\n" + ] + } + ], + "source": [ + "parameters, t_X = predict_test_case()\n", + "\n", + "predictions = predict(parameters, t_X)\n", + "print(\"Predictions: \" + str(predictions))\n", + "\n", + "predict_test(predict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Expected output***\n", + "```\n", + "Predictions: [[ True False True]]\n", + "All tests passed!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 5.2 - Test the Model on the Planar Dataset\n", + "\n", + "It's time to run the model and see how it performs on a planar dataset. Run the following code to test your model with a single hidden layer of $n_h$ hidden units!" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 200)\n", + "Cost after iteration 0: 0.693159\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.272171\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.043260\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.032829\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.029355\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 5000: 0.027294\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 6000: 0.025809\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 7000: 0.024644\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 8000: 0.023688\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 9000: 0.022884\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.00164831 0.00176699 0.00190685 ... 0.99829199 0.99829199 0.99829199]]\n", + "[[0. 0. 0. ... 1. 1. 1.]]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Decision Boundary for hidden layer size 4')" + ] + }, + "execution_count": 192, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Build a model with a n_h-dimensional hidden layer\n", + "parameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)\n", + "\n", + "# Plot the decision boundary\n", + "plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)\n", + "plt.title(\"Decision Boundary for hidden layer size \" + str(4))" + ] + }, + { + "cell_type": "code", + "execution_count": 194, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[9.99987666e-01 4.68332918e-08 9.55206063e-01 6.84508430e-04\n", + " 3.87648806e-04 4.99426860e-11 9.99998368e-01 9.95886873e-01\n", + " 3.68959022e-01 9.99999698e-01 8.46163305e-08 1.00000000e+00\n", + " 9.99737674e-01 9.99999913e-01 9.99999914e-01 8.32763264e-04\n", + " 9.99502050e-01 9.97893651e-01 7.14142919e-01 9.99999914e-01\n", + " 9.99873981e-01 9.99997078e-01 1.47500352e-08 8.74276322e-04\n", + " 9.99999842e-01 3.08689669e-05 7.45001029e-01 9.98807695e-01\n", + " 9.57334544e-01 9.97187476e-01 4.05387180e-07 9.99999913e-01\n", + " 1.40970849e-06 2.30826003e-06 3.30677410e-04 9.97620200e-01\n", + " 9.99998711e-01 8.73764427e-04 8.22662988e-09 7.62760785e-04\n", + " 2.38662877e-12 1.93995791e-04 5.53941992e-07 1.84239523e-02\n", + " 6.97725057e-10 2.27656021e-04 8.06202864e-04 7.77566149e-11\n", + " 9.99999999e-01 9.99998515e-01 9.99976393e-01 1.83771818e-02\n", + " 8.66330970e-01 9.66371012e-08 9.99996435e-01 9.98218060e-01\n", + " 5.51859512e-11 9.99950196e-01 3.87780544e-07 8.33534574e-04\n", + " 9.57398798e-04 9.99981978e-01 2.02188355e-07 9.99999992e-01\n", + " 9.99999898e-01 2.14919409e-07 9.99999297e-01 9.99999780e-01\n", + " 4.16383600e-11 6.55079341e-09 9.97965738e-01 1.00000000e+00\n", + " 7.44021999e-03 9.99999999e-01 9.99822032e-01 9.99872607e-01\n", + " 4.39186114e-11 8.34480544e-01 9.89787061e-01 9.99999912e-01\n", + " 9.99999720e-01 1.06796964e-10 2.13771339e-04 9.97994210e-01\n", + " 9.99999867e-01 2.42219385e-04 9.90127611e-01 9.99971543e-01\n", + " 7.00265280e-08 6.15344150e-08 2.93963201e-02 1.17622903e-08\n", + " 5.10890086e-08 4.16078874e-11 9.99999783e-01 9.10473224e-11\n", + " 4.06872200e-06 9.99999934e-01 1.30165658e-10 4.15065478e-03\n", + " 5.58467962e-08 6.52728660e-11 9.98294732e-01 3.49225990e-06\n", + " 2.96802161e-10 1.98194543e-02 1.76962546e-07 6.25226625e-05\n", + " 9.99999321e-01 9.99805061e-01 9.94900776e-01 5.65414454e-08\n", + " 9.94486814e-01 7.53775181e-04 9.99999796e-01 9.99999887e-01\n", + " 2.06131811e-08 5.14053729e-09 5.46865950e-03 9.99999895e-01\n", + " 9.99999827e-01 4.76970443e-09 7.96535922e-09 9.99999899e-01\n", + " 9.98283569e-01 9.94173007e-01 2.41732510e-07 9.67969936e-01\n", + " 9.99999915e-01 1.66714437e-08 9.79207161e-01 9.99999914e-01\n", + " 9.43196487e-05 5.78892816e-08 9.34989326e-01 9.59759465e-08\n", + " 9.99999913e-01 5.04617449e-07 4.44354328e-02 7.67194532e-01\n", + " 9.99934626e-01 5.68964583e-11 1.07074526e-03 8.37892435e-04\n", + " 1.47895010e-06 9.01423381e-01 9.99285480e-01 4.15163578e-10\n", + " 9.98424259e-01 8.42463937e-01 9.87983937e-02 1.28230064e-07\n", + " 9.99998936e-01 1.42696482e-05 9.99339549e-01 2.21946354e-11\n", + " 9.99999893e-01 9.99999247e-01 6.30079406e-11 9.99999995e-01\n", + " 9.98569864e-01 9.98295707e-01 8.28205698e-04 7.59469247e-04\n", + " 9.99999875e-01 1.00000000e+00 9.99999877e-01 9.99999992e-01\n", + " 9.75595108e-04 9.99977320e-01 9.59319151e-01 9.99977086e-01\n", + " 1.00000000e+00 9.99751587e-01 7.98619996e-04 9.98296952e-01\n", + " 9.99999894e-01 9.98492110e-01 9.89372051e-03 9.99999998e-01\n", + " 1.04506113e-02 9.99683340e-01 9.99999900e-01 9.99955412e-01\n", + " 7.65972448e-04 1.03005745e-10 2.36475898e-06 3.23599538e-04\n", + " 5.23453144e-14 9.99999872e-01 5.67056721e-08 9.99679118e-01\n", + " 1.03266213e-07 9.98297479e-01 7.88725259e-10 3.66967031e-11\n", + " 2.81004994e-04 1.43609472e-05 2.52575120e-04 9.99999990e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy: 99%\n" + ] + } + ], + "source": [ + "# Print accuracy\n", + "predictions = predict(parameters, X)\n", + "print ('Accuracy: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Output**: \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "
Accuracy 90%
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Accuracy is really high compared to Logistic Regression. The model has learned the patterns of the flower's petals! Unlike logistic regression, neural networks are able to learn even highly non-linear decision boundaries. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Congrats on finishing this Programming Assignment! \n", + "\n", + "Here's a quick recap of all you just accomplished: \n", + "\n", + "- Built a complete 2-class classification neural network with a hidden layer\n", + "- Made good use of a non-linear unit\n", + "- Computed the cross entropy loss\n", + "- Implemented forward and backward propagation\n", + "- Seen the impact of varying the hidden layer size, including overfitting.\n", + "\n", + "You've created a neural network that can learn patterns! Excellent work. Below, there are some optional exercises to try out some other hidden layer sizes, and other datasets. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 6 - Tuning hidden layer size (optional/ungraded exercise)\n", + "\n", + "Run the following code(it may take 1-2 minutes). Then, observe different behaviors of the model for various hidden layer sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 200)\n", + "Cost after iteration 0: 0.693144\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.296197\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.296239\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.296240\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.296241\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.97628412 0.97630613 0.97632794 ... 0.01495943 0.01498407 0.01500894]]\n", + "[[1. 1. 1. ... 0. 0. 0.]]\n", + "[[0.91970942 0.03883243 0.94690653 0.04747466 0.76827363 0.01705858\n", + " 0.96394724 0.14122897 0.73309814 0.49325001 0.29521634 0.97468245\n", + " 0.96041369 0.91563362 0.95871427 0.11810214 0.95985041 0.82864603\n", + " 0.94018118 0.94261469 0.18209833 0.24695554 0.03213699 0.331976\n", + " 0.75109494 0.83449944 0.95399541 0.94754166 0.96601572 0.71486669\n", + " 0.0327542 0.90367303 0.22209109 0.67179369 0.02415446 0.92478462\n", + " 0.9731964 0.60871714 0.02478882 0.05430598 0.0206948 0.83249103\n", + " 0.03282879 0.90818166 0.02392493 0.030074 0.05154516 0.02269455\n", + " 0.9757781 0.97433029 0.18498673 0.70867835 0.9684072 0.27039671\n", + " 0.96804834 0.86193082 0.02088409 0.94603618 0.02867527 0.10166216\n", + " 0.0875151 0.97063318 0.03426134 0.96618389 0.78574654 0.02287027\n", + " 0.34813247 0.63140863 0.01858206 0.0188345 0.83868843 0.97260922\n", + " 0.5780397 0.97082383 0.97407025 0.9640713 0.01797943 0.89865346\n", + " 0.86494346 0.92819602 0.9592089 0.02366951 0.04413358 0.97102892\n", + " 0.88736384 0.04358491 0.97235345 0.19371263 0.11971851 0.02472093\n", + " 0.06217458 0.03915731 0.03481106 0.01849956 0.96391783 0.01969756\n", + " 0.04904717 0.96363345 0.02030611 0.75403979 0.091502 0.02002399\n", + " 0.92017114 0.02904887 0.02173248 0.06770133 0.43436263 0.05193978\n", + " 0.96392192 0.68862392 0.88934775 0.10648313 0.96141411 0.07090498\n", + " 0.96764936 0.81020066 0.03400686 0.02197419 0.14575997 0.97128707\n", + " 0.96574522 0.02029008 0.02473999 0.9515548 0.90309953 0.97393129\n", + " 0.51457589 0.96492898 0.96916286 0.03264435 0.93708589 0.93543656\n", + " 0.51294637 0.09779544 0.96293514 0.28731449 0.90583005 0.3877431\n", + " 0.6255624 0.94874368 0.96814951 0.02086858 0.22602857 0.07809973\n", + " 0.02225636 0.96965595 0.97495859 0.02096556 0.96109646 0.36262661\n", + " 0.90085151 0.12243585 0.52382618 0.65671122 0.97538292 0.01853621\n", + " 0.88493186 0.97059405 0.01984618 0.96655916 0.94195879 0.91911689\n", + " 0.12046392 0.06307924 0.60550814 0.97547782 0.62615049 0.970282\n", + " 0.24703084 0.94692124 0.10656201 0.96680288 0.97578154 0.97171051\n", + " 0.07314217 0.92240781 0.97370114 0.94998088 0.87105751 0.97210629\n", + " 0.12456306 0.96952132 0.77380968 0.96140274 0.06807687 0.02390062\n", + " 0.73769995 0.05584633 0.01837255 0.87914265 0.08459217 0.96636149\n", + " 0.33023007 0.93282786 0.02512581 0.01724893 0.02423182 0.81932068\n", + " 0.84810927 0.96603008]]\n", + "[[1. 0. 1. 0. 1. 0. 1. 0. 1. 0. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 0. 0.\n", + " 1. 1. 1. 1. 1. 1. 0. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0.\n", + " 1. 1. 0. 1. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 1.\n", + " 1. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 0. 1. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 0. 1. 1. 1. 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 0. 1. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 1. 1. 1.]]\n", + "Accuracy for 1 hidden units: 85.5 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.693172\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.266315\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.256138\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.252595\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.251160\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[9.85489087e-01 9.85489106e-01 9.85489123e-01 ... 9.21009278e-05\n", + " 9.21027831e-05 9.21047130e-05]]\n", + "[[1. 1. 1. ... 0. 0. 0.]]\n", + "[[9.25076132e-01 2.82138963e-04 9.79599630e-01 5.02255143e-04\n", + " 4.58576121e-01 9.22375121e-05 9.85162986e-01 2.49468617e-01\n", + " 4.40958985e-01 4.11353987e-01 3.95982644e-01 9.85487434e-01\n", + " 9.84790907e-01 9.01544710e-01 9.84274293e-01 1.40926009e-01\n", + " 9.84715623e-01 5.43811987e-01 9.74212600e-01 9.75391697e-01\n", + " 3.27162343e-01 3.77755342e-01 1.42732192e-04 3.94411628e-01\n", + " 4.46786726e-01 5.45944039e-01 9.83136645e-01 9.80845995e-01\n", + " 9.85278559e-01 4.39248450e-01 1.47298201e-04 8.35429133e-01\n", + " 3.75976066e-01 4.26897422e-01 9.72202172e-05 9.49250263e-01\n", + " 9.85480923e-01 4.19123197e-01 1.00462470e-04 1.15430255e-03\n", + " 9.40133505e-05 5.38680256e-01 1.48006426e-04 8.80254886e-01\n", + " 9.83102711e-05 1.15817665e-04 7.41818127e-04 9.60045895e-05\n", + " 9.85488951e-01 9.85486344e-01 3.32860875e-01 4.36041261e-01\n", + " 9.85394699e-01 3.91186174e-01 9.85377981e-01 6.52273847e-01\n", + " 9.39311695e-05 9.78898700e-01 1.15000760e-04 8.04513111e-02\n", + " 4.20038227e-02 9.85457470e-01 1.60019847e-04 9.85307865e-01\n", + " 4.64648722e-01 9.57260234e-05 4.01195050e-01 4.20659833e-01\n", + " 9.26230817e-05 9.28997556e-05 5.68751456e-01 9.85478100e-01\n", + " 4.15176502e-01 9.85458022e-01 9.85485459e-01 9.85181010e-01\n", + " 9.24639897e-05 8.18782226e-01 6.55584647e-01 9.47393561e-01\n", + " 9.84439542e-01 9.75942821e-05 3.66124468e-04 9.85459606e-01\n", + " 7.43086589e-01 3.42335469e-04 9.85475140e-01 3.43459376e-01\n", + " 2.07668584e-01 9.88551968e-05 5.69174986e-03 2.39244369e-04\n", + " 1.86705725e-04 9.25936582e-05 9.85157236e-01 9.30761551e-05\n", + " 7.42415404e-04 9.85130060e-01 9.34288478e-05 4.42075827e-01\n", + " 8.91760385e-02 9.32805572e-05 9.41471972e-01 1.12221775e-04\n", + " 9.49615305e-05 1.02439174e-02 4.09652825e-01 1.46193948e-03\n", + " 9.85159495e-01 4.28998299e-01 7.84653240e-01 1.57759506e-01\n", + " 9.84825659e-01 1.02808535e-02 9.85378847e-01 4.92516030e-01\n", + " 1.65056254e-04 9.56828463e-05 2.50244096e-01 9.85461255e-01\n", + " 9.85277129e-01 9.33527802e-05 1.01185876e-04 9.81995208e-01\n", + " 8.71436045e-01 9.85484895e-01 4.13482604e-01 9.85212443e-01\n", + " 9.85412261e-01 1.48023573e-04 9.71018063e-01 9.65042836e-01\n", + " 4.13150001e-01 1.21950861e-01 9.85032401e-01 3.94851331e-01\n", + " 8.47824427e-01 4.06262746e-01 4.21774714e-01 9.80783170e-01\n", + " 9.85389295e-01 9.39763234e-05 3.57146931e-01 1.93536048e-02\n", + " 9.49384957e-05 9.85431312e-01 9.85487804e-01 9.38786085e-05\n", + " 9.84778437e-01 4.03623508e-01 8.36095803e-01 2.15023113e-01\n", + " 4.13374275e-01 4.25295941e-01 9.85488482e-01 9.26644553e-05\n", + " 7.27628635e-01 9.85453307e-01 9.32708841e-05 9.85326580e-01\n", + " 9.77138561e-01 9.37656723e-01 1.47946258e-01 3.72205156e-03\n", + " 4.18124534e-01 9.85488672e-01 4.19733870e-01 9.85450258e-01\n", + " 3.68946336e-01 9.79511902e-01 1.30754538e-01 9.85320898e-01\n", + " 9.85488984e-01 9.85468813e-01 1.30611164e-02 9.47049909e-01\n", + " 9.85483558e-01 9.82103148e-01 6.67790960e-01 9.85474380e-01\n", + " 1.87339143e-01 9.85430215e-01 4.58148370e-01 9.84911310e-01\n", + " 7.00566557e-03 9.79929451e-05 4.44150289e-01 2.19284521e-03\n", + " 9.26433179e-05 6.96085083e-01 5.98263154e-02 9.85328266e-01\n", + " 4.01053777e-01 9.68013969e-01 1.00046309e-04 9.22801445e-05\n", + " 9.73774884e-05 5.15015240e-01 5.80019598e-01 9.85299819e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 0. 0. 0. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 0. 0.\n", + " 0. 1. 1. 1. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0.\n", + " 1. 1. 0. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 0. 0. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 0. 1. 0. 1. 0. 1. 0. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 1. 1. 1. 0. 1. 1. 1. 1. 1. 0. 1. 0. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 1. 1. 1.]]\n", + "Accuracy for 2 hidden units: 86.5 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.693175\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.265841\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.059886\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.053967\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.051369\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.99996413 0.99997 0.9999746 ... 0.99915076 0.99918484 0.99921658]]\n", + "[[1. 1. 1. ... 1. 1. 1.]]\n", + "[[9.93114148e-01 5.68584251e-04 9.02012770e-01 3.41214256e-04\n", + " 2.33045057e-02 2.98153580e-04 9.98868891e-01 8.21143097e-01\n", + " 3.15241827e-01 9.99989183e-01 4.13817773e-03 9.99606055e-01\n", + " 9.99226404e-01 9.99996845e-01 9.99998194e-01 3.47074517e-04\n", + " 9.99322854e-01 9.90748177e-01 4.15909904e-01 9.99997151e-01\n", + " 9.92040059e-01 9.99950864e-01 3.75096561e-07 3.97967394e-04\n", + " 9.99944435e-01 8.08111275e-02 7.37061146e-01 9.98897855e-01\n", + " 9.93710379e-01 9.52764756e-01 1.77122135e-07 9.99996671e-01\n", + " 7.49120508e-03 1.12967971e-02 3.36587853e-04 9.88624331e-01\n", + " 9.99998216e-01 8.03590434e-02 1.99507382e-08 3.41477575e-04\n", + " 2.22553286e-10 3.11409657e-02 1.87793612e-07 2.32436993e-01\n", + " 1.37550443e-06 3.37214892e-04 3.37573901e-04 7.50063680e-05\n", + " 9.99367572e-01 9.98220124e-01 9.99602134e-01 1.99192869e-01\n", + " 9.85116946e-01 4.26737007e-03 9.99956857e-01 9.97745732e-01\n", + " 1.82376847e-04 9.95402400e-01 8.57549675e-08 3.47895396e-04\n", + " 4.22218117e-04 9.99636221e-01 3.10474328e-05 9.97961379e-01\n", + " 9.99996116e-01 3.33402128e-04 9.99980826e-01 9.99960437e-01\n", + " 1.76459731e-04 7.72347112e-10 9.92665634e-01 9.99137263e-01\n", + " 3.21730341e-02 9.98447915e-01 9.97760584e-01 9.99398934e-01\n", + " 1.90822655e-06 4.66737601e-01 9.36625620e-01 9.99996912e-01\n", + " 9.99957405e-01 5.84197152e-05 3.52279620e-04 9.90425448e-01\n", + " 9.99922566e-01 3.49801305e-04 9.94806308e-01 9.99861238e-01\n", + " 4.52599250e-03 3.30446147e-04 6.85570005e-02 3.67735216e-04\n", + " 6.12466105e-04 1.83881525e-04 9.98411374e-01 2.94993961e-04\n", + " 5.02676159e-04 9.97718830e-01 3.01722076e-04 6.10299494e-02\n", + " 2.69259741e-03 2.62114064e-04 9.99536421e-01 3.35490448e-04\n", + " 1.70015075e-07 1.81607462e-01 7.25847813e-03 1.30922023e-03\n", + " 9.98700064e-01 9.49255694e-01 9.71747470e-01 2.67135350e-03\n", + " 9.93909366e-01 4.19321099e-04 9.99260005e-01 9.99976072e-01\n", + " 1.96329097e-06 2.98641761e-09 1.63846357e-03 9.99999457e-01\n", + " 9.91638099e-01 3.30898341e-04 2.60777292e-08 9.99990525e-01\n", + " 9.99136629e-01 9.98064939e-01 6.88915488e-03 9.31133782e-01\n", + " 9.99999336e-01 5.34119779e-07 8.35972570e-01 9.99997226e-01\n", + " 6.47895830e-02 2.30877133e-03 8.88943899e-01 4.36994515e-03\n", + " 9.99996773e-01 1.16292031e-02 1.59677040e-01 7.05884371e-01\n", + " 9.85281242e-01 5.74144997e-05 5.04327798e-04 3.74837376e-04\n", + " 3.35036686e-04 9.95571499e-01 9.98885571e-01 3.17621783e-04\n", + " 9.96298169e-01 8.82222631e-01 8.21643658e-02 9.45206005e-03\n", + " 9.99810189e-01 4.46644765e-02 9.99239814e-01 7.09467457e-09\n", + " 9.99970211e-01 9.94924465e-01 6.49004851e-06 9.97605888e-01\n", + " 9.98828532e-01 9.99426197e-01 3.44296808e-04 3.51529516e-04\n", + " 9.99993625e-01 9.99539857e-01 9.99994808e-01 9.99378150e-01\n", + " 4.55461027e-04 9.97039068e-01 8.62903667e-01 9.99842643e-01\n", + " 9.99650103e-01 9.93480238e-01 4.34365725e-04 9.99477124e-01\n", + " 9.99999859e-01 9.99425165e-01 4.69414286e-02 9.99494729e-01\n", + " 2.30228042e-03 9.86981604e-01 9.99992776e-01 9.98995673e-01\n", + " 3.66112184e-04 7.70547011e-05 1.70870096e-02 9.47782917e-03\n", + " 1.08951270e-11 9.99933222e-01 2.77379295e-03 9.99578100e-01\n", + " 4.75338787e-03 9.99609935e-01 3.04978347e-04 1.40215045e-04\n", + " 3.36572888e-04 4.97455535e-02 4.09611503e-02 9.98098783e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 0. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy for 3 hidden units: 98.5 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.693159\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.272171\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.043260\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.032829\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.029355\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.0020827 0.0021743 0.00227831 ... 0.99787126 0.99787126 0.99787126]]\n", + "[[0. 0. 0. ... 1. 1. 1.]]\n", + "[[9.99027423e-01 1.84649094e-06 9.24764060e-01 1.19847244e-03\n", + " 3.08163409e-03 5.13110335e-09 9.99973952e-01 9.78889693e-01\n", + " 5.41919533e-01 9.99974066e-01 3.31706978e-06 9.99999986e-01\n", + " 9.99326570e-01 9.99992843e-01 9.99992929e-01 1.32448716e-03\n", + " 9.99005707e-01 9.97323176e-01 6.52353426e-01 9.99992724e-01\n", + " 9.97894183e-01 9.99895744e-01 2.80170827e-06 1.40755334e-03\n", + " 9.99983994e-01 3.05789423e-04 7.57381203e-01 9.98300138e-01\n", + " 9.26511895e-01 9.96273715e-01 3.39818722e-05 9.99992796e-01\n", + " 1.55030042e-05 5.56292352e-05 8.58295463e-04 9.96652405e-01\n", + " 9.99580854e-01 1.30755170e-02 7.61978759e-07 1.26191338e-03\n", + " 1.35327058e-08 1.30346224e-03 3.89667672e-05 3.57142814e-02\n", + " 7.16544044e-08 7.10852626e-04 1.27491525e-03 8.49927717e-09\n", + " 9.99999987e-01 9.99996551e-01 9.99520253e-01 3.06379692e-02\n", + " 8.79011412e-01 3.20708836e-06 9.99274748e-01 9.97766015e-01\n", + " 5.68335385e-09 9.97558580e-01 1.11263500e-05 1.33240700e-03\n", + " 1.78285190e-03 9.99842353e-01 8.23176432e-06 9.99999636e-01\n", + " 9.99991043e-01 1.75842048e-05 9.99963818e-01 9.99981881e-01\n", + " 3.69310853e-09 4.40867954e-07 9.97422755e-01 9.99999985e-01\n", + " 1.00253385e-02 9.99999964e-01 9.99835375e-01 9.99554641e-01\n", + " 3.71917041e-09 8.31430583e-01 9.87576366e-01 9.99992652e-01\n", + " 9.99930088e-01 1.23017542e-08 7.33822781e-04 9.97952097e-01\n", + " 9.99981664e-01 7.69016904e-04 9.92208728e-01 9.99548035e-01\n", + " 4.21653019e-06 6.92199522e-06 2.40138450e-02 2.06649441e-06\n", + " 1.90199238e-06 3.69293502e-09 9.99994071e-01 1.22144060e-08\n", + " 1.61494465e-04 9.99997766e-01 1.97851315e-08 5.75818907e-03\n", + " 2.71786175e-06 7.45051391e-09 9.97872788e-01 8.51721612e-05\n", + " 3.27304290e-08 5.32187755e-02 5.09160230e-06 7.23626095e-04\n", + " 9.99986073e-01 9.95466211e-01 9.93641379e-01 2.50306314e-06\n", + " 9.72243503e-01 1.64994436e-03 9.99993482e-01 9.99988824e-01\n", + " 2.87575284e-06 3.95615580e-07 9.83506672e-03 9.99982747e-01\n", + " 9.99998063e-01 1.05348077e-06 5.83488134e-07 9.99986930e-01\n", + " 9.97855351e-01 9.96090633e-01 8.73590153e-06 9.63746137e-01\n", + " 9.99992785e-01 3.06524199e-06 9.54959506e-01 9.99992917e-01\n", + " 2.80109734e-03 2.24995017e-06 9.27359269e-01 3.24534157e-06\n", + " 9.99992807e-01 2.80660087e-05 5.34548961e-02 7.78591073e-01\n", + " 9.99857219e-01 5.57879539e-09 1.80736356e-03 1.47585212e-03\n", + " 5.94245349e-05 8.98848978e-01 9.99532810e-01 8.27937936e-08\n", + " 9.84518475e-01 7.25326967e-01 1.34735407e-01 1.10810475e-05\n", + " 9.99934657e-01 1.19668121e-04 9.99604456e-01 4.21670065e-09\n", + " 9.99987785e-01 9.99996603e-01 5.97900991e-09 9.99999772e-01\n", + " 9.98087287e-01 9.97872035e-01 1.31135518e-03 1.31048419e-03\n", + " 9.99989670e-01 9.99999994e-01 9.99989307e-01 9.99999478e-01\n", + " 1.61761649e-03 9.98398130e-01 9.35674185e-01 9.97864629e-01\n", + " 9.99999993e-01 9.99693947e-01 1.76350479e-03 9.97873979e-01\n", + " 9.99980690e-01 9.98039356e-01 2.43383296e-02 9.99999866e-01\n", + " 1.91390614e-02 9.99529381e-01 9.99991498e-01 9.99774859e-01\n", + " 1.38803621e-03 1.20434439e-08 4.80718159e-05 3.14961805e-03\n", + " 5.25677847e-10 9.99983274e-01 3.02848177e-06 9.99203813e-01\n", + " 4.38888484e-06 9.97876006e-01 1.51289093e-07 2.97881712e-09\n", + " 7.98310325e-04 1.73506338e-04 1.51784932e-03 9.99999523e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy for 4 hidden units: 99.0 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.693143\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.266196\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.046866\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.031153\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.024652\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.99637979 0.99740456 0.99815526 ... 0.25188783 0.25189064 0.25189358]]\n", + "[[1. 1. 1. ... 0. 0. 0.]]\n", + "[[9.99919829e-01 1.13604724e-08 9.76114694e-01 3.24860081e-04\n", + " 1.11140995e-04 2.77017935e-08 9.99940449e-01 9.50011199e-01\n", + " 2.17518150e-01 9.99806172e-01 2.27277980e-08 9.99999909e-01\n", + " 9.99460823e-01 9.99998902e-01 9.99999957e-01 3.37985382e-04\n", + " 9.99330344e-01 9.96336014e-01 7.40631793e-01 9.99999897e-01\n", + " 9.93145890e-01 9.99532283e-01 8.79363044e-06 3.91871209e-04\n", + " 9.99929792e-01 2.63089892e-04 8.12637564e-01 9.99103369e-01\n", + " 9.52990687e-01 9.67381074e-01 1.81213694e-04 9.99997604e-01\n", + " 5.32574100e-07 8.63673389e-07 2.90367866e-04 9.98469191e-01\n", + " 9.99839825e-01 1.84037895e-03 6.89480318e-07 3.28570227e-04\n", + " 7.18922830e-08 2.04903044e-04 1.89874512e-04 8.62071574e-02\n", + " 8.01521579e-08 2.75567878e-04 3.20300857e-04 2.43486525e-08\n", + " 9.99999908e-01 9.99977501e-01 9.98454171e-01 2.30016223e-02\n", + " 8.68974659e-01 2.30743812e-08 9.99881805e-01 9.98224812e-01\n", + " 2.32137351e-08 9.99816731e-01 8.55237663e-06 3.40982383e-04\n", + " 5.23595184e-04 9.99743382e-01 5.18763439e-06 9.99998681e-01\n", + " 9.99942308e-01 6.22368988e-05 9.99780666e-01 9.99881552e-01\n", + " 1.43042421e-08 3.74495272e-10 9.96970729e-01 9.99999917e-01\n", + " 1.64649919e-02 9.99999833e-01 9.99140698e-01 9.99567612e-01\n", + " 1.14642667e-08 8.56872341e-01 9.92799813e-01 9.99998967e-01\n", + " 9.99998264e-01 3.07873397e-08 3.06712677e-04 9.94904873e-01\n", + " 9.99995418e-01 3.06274153e-04 9.80528688e-01 9.98836248e-01\n", + " 2.05678556e-07 3.49712166e-05 3.99351354e-02 7.71205625e-06\n", + " 9.84843486e-09 1.44565029e-08 9.99982986e-01 8.88486417e-08\n", + " 2.91677499e-04 9.99993366e-01 1.68715672e-07 1.23293803e-02\n", + " 4.95340291e-08 4.09621651e-08 9.98971929e-01 1.25924061e-04\n", + " 4.69507757e-08 7.06738645e-02 5.46867398e-08 5.77457512e-03\n", + " 9.99964310e-01 9.91124268e-01 9.96751762e-01 2.60712386e-08\n", + " 9.91033555e-01 5.25723589e-04 9.99977549e-01 9.99969559e-01\n", + " 5.30967518e-06 1.33374394e-09 4.39042962e-03 9.99999695e-01\n", + " 9.99995903e-01 1.10874743e-05 7.30901292e-09 9.99999867e-01\n", + " 9.98839275e-01 9.86355329e-01 7.69658348e-08 9.54715392e-01\n", + " 9.99999966e-01 9.96394739e-06 9.88457673e-01 9.99999730e-01\n", + " 5.68411005e-04 1.43371646e-08 9.19178133e-01 2.31493135e-08\n", + " 9.99997654e-01 9.44746170e-07 1.70820750e-02 8.56790101e-01\n", + " 9.99706225e-01 1.66181292e-08 5.75213203e-04 4.07545979e-04\n", + " 1.13602338e-04 8.95992233e-01 9.97230895e-01 9.65317886e-07\n", + " 9.96051694e-01 8.50283303e-01 8.28406342e-02 4.23678734e-06\n", + " 9.99707555e-01 2.19902018e-05 9.97288421e-01 1.63453196e-08\n", + " 9.99996141e-01 9.99988758e-01 1.53016813e-08 9.99999195e-01\n", + " 9.99035523e-01 9.98951302e-01 3.32554028e-04 3.52539818e-04\n", + " 9.99905631e-01 9.99999961e-01 9.99902332e-01 9.99997260e-01\n", + " 4.87952716e-04 9.99895112e-01 9.24122455e-01 9.99544519e-01\n", + " 9.99999953e-01 9.99030244e-01 5.67849632e-04 9.98968741e-01\n", + " 9.99999428e-01 9.99057420e-01 7.20097053e-03 9.99999176e-01\n", + " 8.64866516e-03 9.98923689e-01 9.99955554e-01 9.99726387e-01\n", + " 3.87715024e-04 3.24898877e-08 1.87812375e-06 3.87973373e-03\n", + " 3.28544233e-10 9.99993891e-01 9.77931832e-08 9.99391773e-01\n", + " 3.54408855e-08 9.99011389e-01 1.46899626e-06 1.09293429e-08\n", + " 2.84795357e-04 6.28170801e-05 4.29440539e-04 9.99998261e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy for 5 hidden units: 99.5 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.693332\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.274556\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.060702\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.051522\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.041573\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.01259868 0.01273134 0.01286667 ... 0.95141462 0.95226578 0.9530966 ]]\n", + "[[0. 0. 0. ... 1. 1. 1.]]\n", + "[[9.99947422e-01 3.03483969e-10 9.55504012e-01 1.05229107e-05\n", + " 1.35773444e-03 5.65998000e-10 9.99821461e-01 9.30343941e-01\n", + " 3.39532508e-01 9.99712042e-01 6.19454552e-07 9.99999242e-01\n", + " 9.99913529e-01 9.99999389e-01 9.99999888e-01 7.97980428e-05\n", + " 9.99945062e-01 9.94816317e-01 7.34744599e-01 9.99999922e-01\n", + " 9.83186095e-01 9.98951461e-01 2.54171776e-09 5.91055530e-04\n", + " 9.99999382e-01 2.16888945e-02 7.65788887e-01 9.99849818e-01\n", + " 9.63282014e-01 9.46495643e-01 5.57718795e-06 9.99999264e-01\n", + " 2.93464734e-05 1.25268835e-04 1.83872956e-07 9.91795989e-01\n", + " 9.99988510e-01 3.48435213e-03 1.32041810e-04 1.50879721e-05\n", + " 1.61102175e-06 5.94896575e-03 7.86469142e-06 2.47814727e-01\n", + " 1.85628123e-04 9.26771549e-07 6.78490191e-06 7.57715139e-06\n", + " 9.99955302e-01 9.98139903e-01 9.93762784e-01 7.46491139e-02\n", + " 8.96396449e-01 1.62202610e-06 9.99977885e-01 9.99405750e-01\n", + " 2.36249011e-07 9.99823858e-01 2.36425212e-04 6.94617403e-05\n", + " 3.83815878e-04 9.99995119e-01 1.38908695e-03 9.99807229e-01\n", + " 9.99977314e-01 5.04476461e-08 9.99868777e-01 9.99997550e-01\n", + " 4.41294939e-08 6.43145194e-11 9.96333852e-01 9.99985140e-01\n", + " 1.49532679e-02 9.99940090e-01 9.91206276e-01 9.99957538e-01\n", + " 1.40084679e-05 7.54343611e-01 9.40446934e-01 9.99989412e-01\n", + " 9.99999664e-01 1.81317810e-05 2.26392242e-05 9.85202814e-01\n", + " 9.99999869e-01 1.83854101e-05 9.68471398e-01 9.95999598e-01\n", + " 8.38813460e-09 1.07745203e-07 2.09359305e-02 6.22044718e-04\n", + " 8.81890556e-10 3.45744582e-08 9.99732914e-01 5.51256872e-09\n", + " 1.30367439e-03 9.99615351e-01 7.48423711e-09 1.26768900e-02\n", + " 2.00007454e-09 1.73206067e-08 9.99988918e-01 7.58537253e-07\n", + " 1.31040725e-04 1.19996166e-01 2.62975239e-05 7.04305955e-05\n", + " 9.99784948e-01 9.98692908e-01 9.77681237e-01 4.16263933e-09\n", + " 9.92298754e-01 3.59700920e-04 9.99949216e-01 9.99999731e-01\n", + " 1.13360971e-09 1.49351247e-11 1.70266471e-02 9.99999983e-01\n", + " 9.99066947e-01 7.39840707e-09 1.82208583e-11 9.99999978e-01\n", + " 9.99928658e-01 9.69957836e-01 1.22512141e-05 9.54891146e-01\n", + " 9.99999979e-01 2.75804307e-09 8.90988244e-01 9.99999139e-01\n", + " 7.89509340e-04 8.47245693e-09 9.30665285e-01 1.79081988e-06\n", + " 9.99998975e-01 3.33555606e-06 4.74152357e-02 7.73472518e-01\n", + " 9.95854474e-01 4.07108414e-06 9.28416901e-04 1.33983059e-04\n", + " 5.00455244e-08 9.24132102e-01 9.83073588e-01 9.08207761e-09\n", + " 9.96943883e-01 8.61327291e-01 9.78830845e-02 5.78478276e-08\n", + " 9.99985248e-01 4.81640953e-03 9.81797689e-01 4.49469585e-05\n", + " 9.99999911e-01 9.98960425e-01 1.96503169e-05 9.99797842e-01\n", + " 9.99847693e-01 9.99978814e-01 6.93468895e-05 4.24610281e-05\n", + " 9.99989216e-01 9.99997760e-01 9.99971890e-01 9.99982783e-01\n", + " 7.32532397e-04 9.99912611e-01 8.20341422e-01 9.99867719e-01\n", + " 9.99999706e-01 9.92751400e-01 4.74204043e-04 9.99984628e-01\n", + " 9.99999979e-01 9.99980155e-01 2.44131795e-02 9.99994412e-01\n", + " 4.60679373e-02 9.93003702e-01 9.99999110e-01 9.99828691e-01\n", + " 8.86435113e-05 1.36987450e-05 7.05447962e-04 3.21092740e-02\n", + " 9.08023591e-11 9.99999868e-01 1.62039862e-09 9.99989736e-01\n", + " 6.70590349e-07 9.99995393e-01 2.07591307e-07 3.06623662e-08\n", + " 1.86364127e-07 9.38076020e-03 1.12436363e-02 9.99810288e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy for 20 hidden units: 99.5 %\n", + "(2, 200)\n", + "Cost after iteration 0: 0.692917\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 1000: 0.096385\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 2000: 0.058778\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 3000: 0.051543\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "Cost after iteration 4000: 0.046033\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "(2, 200)\n", + "[[0.31955715 0.33813698 0.35715023 ... 0.99997185 0.999975 0.99997779]]\n", + "[[0. 0. 0. ... 1. 1. 1.]]\n", + "[[9.99920136e-01 2.91495929e-10 9.54086202e-01 4.19702893e-06\n", + " 2.46231110e-03 1.55304072e-08 9.99542567e-01 8.30300041e-01\n", + " 3.03814609e-01 9.99505286e-01 2.71852141e-06 9.99995979e-01\n", + " 9.99680180e-01 9.99999945e-01 9.99999997e-01 4.30801400e-06\n", + " 9.99782868e-01 9.95865696e-01 6.96605264e-01 9.99999997e-01\n", + " 9.54913787e-01 9.98743524e-01 1.04393246e-09 4.37440973e-05\n", + " 9.99999757e-01 2.71233736e-02 7.86134409e-01 9.99431999e-01\n", + " 9.73686071e-01 9.78571455e-01 2.05647088e-06 9.99999919e-01\n", + " 1.94525801e-04 2.84321811e-04 5.25592282e-08 9.77957323e-01\n", + " 9.99991702e-01 5.17357395e-03 3.62477453e-05 3.41518319e-06\n", + " 1.05934136e-07 9.53570934e-03 2.95969557e-06 2.65727490e-01\n", + " 9.84186781e-05 8.81942020e-07 1.79348998e-07 1.17544545e-05\n", + " 9.99837387e-01 9.96851531e-01 9.90328120e-01 1.00661164e-01\n", + " 9.25808883e-01 7.99338478e-06 9.99981337e-01 9.99593615e-01\n", + " 1.32301238e-06 9.99769718e-01 1.01231007e-04 6.09734244e-06\n", + " 4.74755941e-04 9.99984920e-01 1.66592132e-03 9.99511367e-01\n", + " 9.99987690e-01 2.64487695e-07 9.99889618e-01 9.99998909e-01\n", + " 3.56355654e-07 1.07523249e-12 9.96897694e-01 9.99932298e-01\n", + " 4.31906981e-02 9.99774700e-01 9.89903737e-01 9.99848104e-01\n", + " 5.40694038e-06 7.15058871e-01 9.00887602e-01 9.99998616e-01\n", + " 9.99999825e-01 2.31281762e-05 5.39655251e-05 9.81718475e-01\n", + " 9.99999954e-01 4.04063406e-05 9.71446251e-01 9.96148382e-01\n", + " 3.47540332e-08 8.90100270e-07 3.92150773e-02 8.73871867e-04\n", + " 5.89722615e-10 3.07973471e-07 9.99375858e-01 1.20462854e-07\n", + " 1.85720458e-03 9.99135094e-01 1.55968484e-07 3.33616695e-02\n", + " 7.99832407e-09 2.74190757e-07 9.99994616e-01 3.68691116e-06\n", + " 4.02229680e-05 2.02530377e-01 8.79059517e-05 6.73396168e-05\n", + " 9.99473761e-01 9.97936486e-01 9.53849809e-01 1.90881246e-08\n", + " 9.93122507e-01 6.07441768e-04 9.99867665e-01 9.99999927e-01\n", + " 5.92958708e-10 1.02079946e-12 2.25197245e-02 9.99999998e-01\n", + " 9.97616554e-01 6.48987071e-08 2.73285472e-12 9.99999997e-01\n", + " 9.99942289e-01 9.75734731e-01 3.54079005e-05 9.45087257e-01\n", + " 1.00000000e+00 1.19040602e-09 8.64750838e-01 9.99999944e-01\n", + " 1.37087896e-03 4.01314433e-08 9.19680742e-01 8.42648605e-06\n", + " 9.99999884e-01 1.04654307e-05 9.19626464e-02 7.88506000e-01\n", + " 9.91958065e-01 5.98423990e-06 4.47360591e-04 1.11022049e-04\n", + " 1.43831260e-07 9.51552573e-01 9.85161672e-01 1.62515497e-07\n", + " 9.97096584e-01 8.75527638e-01 1.12032008e-01 1.89547490e-07\n", + " 9.99991654e-01 8.30637265e-03 9.85059144e-01 4.67614517e-06\n", + " 9.99999980e-01 9.97502488e-01 1.13534907e-05 9.99460959e-01\n", + " 9.99468678e-01 9.99983525e-01 2.32356236e-06 2.37838765e-05\n", + " 9.99993255e-01 9.99985813e-01 9.99976320e-01 9.99951655e-01\n", + " 2.09818429e-04 9.99888507e-01 7.67194154e-01 9.99880027e-01\n", + " 9.99997951e-01 9.89607606e-01 8.02226197e-04 9.99988605e-01\n", + " 9.99999997e-01 9.99935742e-01 3.33533319e-02 9.99981893e-01\n", + " 4.46685027e-02 9.88619987e-01 9.99999757e-01 9.99470087e-01\n", + " 8.28955844e-05 2.01384669e-05 1.32274487e-03 5.09763556e-02\n", + " 2.32384690e-12 9.99999956e-01 5.85781317e-09 9.99960632e-01\n", + " 2.67893449e-06 9.99997502e-01 2.33390333e-06 2.24096092e-07\n", + " 6.60311035e-08 1.31987828e-02 1.69090981e-02 9.99528248e-01]]\n", + "[[1. 0. 1. 0. 0. 0. 1. 1. 0. 1. 0. 1. 1. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0.\n", + " 1. 0. 1. 1. 1. 1. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 1. 1. 1. 0. 1. 0. 1. 1. 0. 1. 0. 0. 0. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 1.\n", + " 0. 1. 1. 1. 0. 1. 1. 1. 1. 0. 0. 1. 1. 0. 1. 1. 0. 0. 0. 0. 0. 0. 1. 0.\n", + " 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 1. 1. 1. 0. 1. 0. 1. 1. 0. 0. 0. 1.\n", + " 1. 0. 0. 1. 1. 1. 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 0. 1. 1. 0. 0. 0.\n", + " 0. 1. 1. 0. 1. 1. 0. 0. 1. 0. 1. 0. 1. 1. 0. 1. 1. 1. 0. 0. 1. 1. 1. 1.\n", + " 0. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1. 0. 1. 1. 1. 0. 0. 0. 0. 0. 1. 0. 1.\n", + " 0. 1. 0. 0. 0. 0. 0. 1.]]\n", + "Accuracy for 50 hidden units: 99.5 %\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7gAAAWhCAYAAAC/MDwyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXCs+1kf+O/zLr1K3a1dOjr7cu0Uxlx7wPY1MJgQEq4xOONgFg8wMIAJCQOpQBjGqYHJJEylZlIZoExiPMONgVBgwIyxgykwYxtjdsZ4t+/1vfcs0tm0d7d6e7dn/ni7W7283WpJLbXU+n6qbt1zpJb61dE5+vbze3+/5xFVBREREREREdFZZ4z6AoiIiIiIiIiGgQUuERERERERjQUWuERERERERDQWWOASERERERHRWGCBS0RERERERGOBBS4RERERERGNBRa4RBFE5LMi8roe73udiKz2+dh3ici/ObaLO0NEJCki7xeRvIj81gE+7rKI7IqIeZzXR0REZwezeTiYzTTuWODSuSMid0Tk73W87XtE5GON36vql6jqR0784vrovMYz4lsALACYUdU3D/pBqnpPVSdU1R/WhYhITER+u/79114vkoiI6OQxm0/Uacrm14jIB0VkS0TWReS3RGRpWJ+fzicWuEQ0EAkd9GfGFQDPqap3HNd0CB8D8J0AHo36QoiIiI5qDLJ5CsA7AVxFeF1FAP9plBdEZx8LXKIIrSvJ9a087xKRbRH5HICv6HjsK0Tk4yJSFJF3A0h0vP8NIvIJEdkRkT8TkZd3PM+Pi8in6luF3i0ibR8/4PV+r4h8vn4NL4rID7a87zMi8k0tv7dFZENEnqz//jX169oRkU+23tkUkY+IyM+IyJ8CKAO4HvHcf6f+uJ369rFvrr/9XwH4KQDfVt/S9H0RH/sqEfkbESmIyGMR+ff1t1+t32W1ROSp+sc3/quKyJ364wwR+UkReUFENkXkN0VkOurPSFUdVf1ZVf0YgKGtPhMR0clgNjcfO07Z/Puq+luqWlDVMoC3A/jKg/5ZE7VigUu0v58GcKP+3z8A8N813iEiMQDvBfCrAKYB/BaAf9Ty/lcCeAbADwKYAfCLAN4nIvGWz/+tAL4BwDUALwfwPYe4xjUAbwCQAfC9AP7P+nMDwK8gvGvZ8HoAD1X1EyKyDOD3APyb+vX/OID3iMhcy+O/C8BbAUwCuNv6pCJiA3g/gD8EMA/gfwDwayLyElX9aQD/G4B317c0/VLEdf8cgJ9T1QzCP9/f7HyAqv55/eMnEK70/gWAX6+/+0cA/EMAXwPgAoBtAL/Q90+KiIjGAbN5PLP5vwbw2QEfSxSJBS6dV++tr2ruiMgOgP/Q57HfCuBnVHVLVVcA/HzL+14DwAbws6rqqupvA/jrlvf/AIBfVNW/VFVfVX8ZQK3+cQ0/r6oPVHULYSA9edAvRlV/T1Vf0NAfIwy1r66/+z8DeL2IZOq//y6EoQ+E4foBVf2Aqgaq+kEAf4MwaBvepaqfVVVPVd2Op34NgAkA/7Z+h/RDAP4LgO8Y8NJdADdFZFZVd1X1L/Z5/M8DKAH4l/Xf/yCAf6mqq6paA/C/APgWEbEGfH4iIjo9mM2hc5nN9bvoPwXgXwx4nUSRWODSefUPVTXX+A/AP+nz2AsAVlp+f7fjffdVVXu8/wqAH+sI7Ev1j2toPQ9aRhhKByIiT4vIX0jYpGEHYQjOAoCqPgDwpwD+kYjkADwN4Ndaru/NHdf3VQBaGzy0fu2dLgBYUdWg5W13ASwPeOnfB+AJAF8Qkb8WkTf0+Rp/EMDrALyl5fmuAPh/Wq798wi3Hy8M+PxERHR6MJv3ru9cZbOI3ATw+wB+VFX/ZMDrJIrEuxxE+3uIMPgaW2Yud7xvWUSkJUgvA3ih/usVhCvMP3NcF1ffUvUeAN8N4HdV1RWR9wKQlof9MoDvR/hv/s9V9X7L9f2qqv5An6fQPu97AOCSiBgtwXYZwHODXLuqfhHAd0jYIONNAH5bRGY6HyciXw3gXwP4KlXNt7xrBcB/r6p/OsjzERHR2GA293amsllErgD4IwD/WlV/db/HE+2Hd3CJ9vebAP4nEZkSkYsIz7I0/DkAD8CP1JsuvAnAq1re/38B+Mci8moJpUXkG0Vk8pDXIiKSaP0PQAxAHMA6AE9Engbw9zs+7r0AXgngRxGe+2n4zwC+SUT+gYiY9c/5uvrXOYi/RLgt6SckbJDxOgDfBOA3BvxivlNE5uoBvFN/s9/xmEsA3g3gu1W1M5zfAeBn6uEIEZkTkTf2eb647DUKidW/Xun1eCIiOrWYzb2dmWyW8LzxhwD8gqq+Y6CvjmgfLHCJ9vevEG7tuY3w/ExzdVFVHYSrm9+DsInCtwH4nZb3/w3Csz5vr7//eRyuUUXDawFUIv77EYRhvw3gLQDe1/pBqlpBuJJ8reP6VgC8EcDbEIbwCsKzLwP9bKh//d+McGvVBsLzUt+tql8Y8Ov5BgCfFZFdhE0tvl1Vqx2P+ToAiwhXkBvdGhsr9j9X/1r/UESKCJtcvLrP8z2L8M9rGcAf1H99ZcBrJSKi04PZ3MMZy+bvR9gF+qdbPs/ugNdJFEnajycQ0bgSkZ8C8ISqfue+DyYiIqJjx2wmGj6ewSU6ByScP/d9CLs0EhER0Ygxm4mOB7coE405EfkBhNubfl9VPzrq6yEiIjrvmM1Ex4dblImIiIiIiGgs8A4uERERERERjQUWuERERERERDQWxrLJVM6K6aKdGvVlEBHRGHi2mt9Q1blRX8dZx2wmIqJh6ZfNY1ngLtopPHPzq0Z9GURENAa+8jO/d3fU1zAOmM1ERDQs/bKZW5SJiIiIiIhoLLDAJSIiIiIiorHAApeIiIiIiIjGAgtcIiIiIiIiGgsscImIiIiIiGgssMAlIiIiIiKiscACl4iIiIiIiMYCC1wiIiIiIiIaCyxwiYiIiIiIaCywwCUiIiIiIqKxwAKXiIiIiIiIxgILXCIiIiIiIhoLLHCJiIiIiIhoLLDAJSIiIiIiorHAApeIiIiIiIjGAgtcIiIiIiIiGgsscImIiIiIiGgssMAlIiIiIiKiscACl4iIiIiIiMbCyApcEbkkIh8Wkc+LyGdF5EcjHiMi8vMi8ryIfEpEXjmKayUiIjoPmM1ERHTWWSN8bg/Aj6nqx0VkEsD/JyIfVNXPtTzmaQC36v+9GsB/rP+fiIiIho/ZTEREZ9rI7uCq6kNV/Xj910UAnwew3PGwNwL4FQ39BYCciCyd8KUSERGdC8xmIiI6607FGVwRuQrgFQD+suNdywBWWn6/iu6gJSIioiFjNhMR0Vk08gJXRCYAvAfAP1PVQue7Iz5Ee3yet4rI34jI3+z4zrAvk4iI6NxgNhMR0Vk10gJXRGyEAfprqvo7EQ9ZBXCp5fcXATyI+lyq+k5V/XJV/fKcGRv+xRIREZ0DzGYiIjrLRtlFWQD8EoDPq+q/7/Gw9wH47nrHxtcAyKvqwxO7SCIionOE2UxERGfdKLsofyWA7wLwaRH5RP1tbwNwGQBU9R0APgDg9QCeB1AG8L0juE4iIqLzgtlMRERn2sgKXFX9GKLP8bQ+RgH805O5IiIiovON2UxERGfdyJtMEREREREREQ0DC1wiIiIiIiIaCyxwiYiIiIiIaCywwCUiIiIiIqKxwAKXiIiIiIiIxgILXCIiIiIiIhoLLHCJiIiIiIhoLLDAJSIiIiIiorHAApeIiIiIiIjGAgtcIiIiIiIiGgsscImIiIiIiGgssMAlIiIiIiKiscACl4iIiIiIiMYCC1wiIiIiIiIaCyxwiYiIiIiIaCywwCUiIiIiIqKxwAKXiIiIiIiIxgILXCIiIiIiIhoLLHCJiIiIiIhoLLDAJSIiIiIiorHAApeIiIiIiIjGAgtcIiIiIiIiGgsscImIiIiIiGgssMAlIiIiIiKiscACl4iIiIiIiMYCC1wiIiIiIiIaCyxwiYiIiIiIaCyMtMAVkWdEZE1EPtPj/a8TkbyIfKL+30+d9DUSERGdJ8xmIiI6y6wRP/+7ALwdwK/0ecyfqOobTuZyiIiIzr13gdlMRERn1Ejv4KrqRwFsjfIaiIiIaA+zmYiIzrKzcAb3KRH5pIj8voh8yagvhoiIiJjNRER0Oo16i/J+Pg7giqruisjrAbwXwK2oB4rIWwG8FQAW7OTJXSEREdH5wmwmIqJT61TfwVXVgqru1n/9AQC2iMz2eOw7VfXLVfXLc2bsRK+TiIjovGA2ExHRaXaqC1wRWRQRqf/6VQivd3O0V0VERHR+MZuJiOg0G+kWZRH5dQCvAzArIqsAfhqADQCq+g4A3wLgh0TEA1AB8O2qqiO6XCIiorHHbCYiorNspAWuqn7HPu9/O8JRBURERHQCmM1ERHSWneotykRERERERESDYoFLREREREREY4EFLhEBAFQVPEZHRER0ejCbiQ7utM/BJaJjpqrYXPewvekhCIBYXDC/aCM9YY760oiIiM4lVcXGmoedrb1sXliykUozm4n2wzu4ROfc2iMXWxthgAKAU1Pcv+egUglGe2FERETn1OOHbnPhGQizefWugyqzmWhfLHCJzjHfV+S3fXTuflIFNtfc0VwUERHROeb7isJOj2xeZzYT7YcFLtE55rkKkej3OTWe+SEiIjppbp9srjGbifbFApfoHLNt6VohbogneqQrERERHZt+2ZxI8KU70X7YZIrolAsCxea629xKnJ4wMbdowbaPHnKGKZiaNrG91b4VSgSYmbOP/PmJiIjGURAoNtbc5lbiMJtt2PbRF4dNU5CdMruOEIXZzJfuRPvhvxKiU+7+PQeVctAMuWLBR7nk49qtBEzz6EE6u2DDtARbGx58H0gkBPNLNhJJrhITERFFiczmso9rN4eTzfOLNixLsL1Zz+akYH4xhjjv4BLtiwUu0SlWqwZtAdoQBEB+28P07NHvsooIpmftoXwuIiKicVet9MhmHyjseJiaGU42z8zZ3E1FdAhcBiI6xWrVAIhYCFYFKhU2miAiIjpptWr0qB5VoMpsJho5FrhEp5gdM4CIrBQB4nE2gSIiIjppdiw6f0WAGLOZaOS4RZnoFEskBbG4oFZtr3JFgNzUYP98G40w8ts+ggBIpgwsLNk8x0NERHQIyZSBWEy6RvaIANmDZPNjF/mdMJtTaQPzSzbicWYz0VHxXxHRkNVqAR6sOnjxi1Ws3q2hUvYP/blEBJeuxjGZ2funGk8ILl2LwxqwU+PDVQc7W2GAAkClHODe7Rpcl9uoiIjofKhVAzxYac3m6G3Gg2hk88TkXjYnkoLL1+KwrMGy+cGKg53tvWwulwLce7EGj9lMdGS8g0s0gFo1wM62B9dVTEyYyORMGEZ3iFWrYfGo9cByHUW55ODCpRgmJs1DPbdpCi5cikNVoYrI5+3FcQKUdqObVG1vuphfjB3qmoiIiEatVg2wveXB9xTpSROZbI9srtSzuZ6FYTbXjpbNlmD58iGzuRagXIrIZgW2t1zMLTCbiY6CBS7RPgp5D4/uu80gKu+GgXrlWhxGxyiA9Udus7htUAUeP3CQfiIBkcOfzRERHPTDnZpCBJED4zu3PRMREZ0Vndlc2g2wvenhyvV4V7G5/sjtykFVYO2hi/SEceLZXOuVzQpUmc1ER8YCl8ZarRagmPehqpjMWAee7aqqePygPRhVw9Xf7S2vq31/tRK95cnzwrumZsdCcaUcYGvThecqUmkTUzPWwNubBhGLSWRxC4RbnYmIiE5arRqgWDh8NgdB72ze2eoeoVfpkc2uq9AAkK5s9rG14cHzwmyenrFgDjOb472zOcFsJjoyFrg0trY2XGysec0Q2d70kZs2D7Qtt9ddTtVwqHtngWuagiDo/hgRwOjI7/yO1xbQtaqH/LaHqzcTQyty/QAwLcBzO67HAKam+c+fiIhO1ua6i8319myemjYxd6Bs7j2mp5j3uwpc05LIs60iYR62ym97ePywPZsLOx6u3BhONqsqAj9c8Pa89vcZBpCb5txboqNikykaS64btBW3QBh8O1t+z7usUQwjentv+L7uoJueNbu2KoVdFc22LVCqirWH3avPvg9srXdUo4egqnh038HK7VpXcZtICi5fjYcjiIiIiE6I4wRtxS0QZt/2lo9qj6I1imH0vgPaeXQIAKZnBsvmIFCsPerOZs8LF82PSlXx6IGLlTu1ruI2mTJw+Voc9oANJImoN77CpbG0W+yzulvwIt8XJRY3IufdiQBTM913QLNTFqZnreYdWxFgMmNifqF9RdapadR42/Dadw/f2bGhXApQyPtdLwBEgItX4gfeDkZERHRUpT7ZvFsYfOJALC6RhaBI9O6k3LSFqZmObM6amF/szuae1z6kbC72yOblyzGO7yMaEu5RpFNJVVHI+yjshIGXnTIxmTEHbgTR71EHbSaxdNHGvdtOW/Oo3LTZNh6g9XPPztuYnrHgugrLkshzO6Yp6FXhdp7TPYyoAA0vECjt+shk+U+fiIgOpjObc1MWJjIHaNI0pJuTIrKXzS1ZNzVtIt0jm+cWbMzMWnBchW1LmMMdTLP3rq2oxx9UYad3NpdLASYzQ3gBQEQscOn0UVXcX3FQbhlvUykH2C0GuHBxsDM66UkD+qj77Y1V20EFgeLBittWjIYrwNIz0FUVYqDvSqxlC5JJA+WOOXwi6Do7dCh9cliG9QqDiIjODVXF6l0HlXJrNjuYLJpYGjCbJyYMrEW8XQTIHCSbfcWD1fYtwyLh9uT9sjnRJ5vtmIFE0uiakRtm8xBeMveIX6Yy0XBxLwSdOpVy0FbcAnvblwY5PxueP3Uj75BOz5qIxwf/a5/f9uC52nUtje6KrcolH3eer+K5z1XxxS9UsfbIgfZaCgawdCmGRFLatkxNz1pDWcHNZLvPG4UXD6QnDv/PPpz3xxEGRETnTbkUoFLpzuZiwe/Z9KmVquLhgx7ZPGchdoBs3umRzZvrHny/O5tvt2Tz+uP+2XwhIptn5qxDz8ttlc1FZ7Mym4mGindw6dQp7UZv4VENg2q/86O7hXCAepSDNLEAwrO8UdciEo4EagRerRpg9e7eVikNwoZWvoeeK9uWJbhyPQGnFsDzFPGEMZQtUADCkUPTJra3fCj2VocvXIpFNuDYj++HTbHCsQ5AKmVg4YJ9oBckRER0dpV3/a4570BYr5ZLwb7nR4sFH5Ue2TxIgdxqv2xOT4TZXK10Z/P2pg/PA5aWTz6bkykD2SkT+e2IbI5oXLkf31c8rmczFEilDSwsMZuJWODSqWNZBkSimzAMEjKFfO8mUqViuMoZtYUpCBSlYoAgUKQmTNi29BwJoGi/ls6ukMDeyvacp31HC8TiBmLx/l/TYcwtxpCdCrd2GwYwkTEPNeJAVbFyp4ZaTZsr7+VygLsv1nD9VmKoswGJRu3Jpz0k3/xKAMDXvuerwjd+5vdGeEVEp0O4/bf7jGq4NXj/j8/v9G4itVvoXeAGgWK3GBbX+2azdmTzhhudzXkf8wvaN7+OI5tFBAtLMeSmA5Tq2TyZMQ+Vo6qKldv1bK4rlwLcvV3P5iEV5URnEQtcOnUmsybWH0e045ewSNvPQZtIAeGd4fv3nLB+UwBwMT0bdl1s3LVsZZmCRHLveWq16HAWCQfPW5agWgmws+XB8xUTkyYyWfNQK7YHEYsbmD7iSm61EoSdJSNeJOR3vOGcGSYaodd++sfwo3/2EADwtvflgPeM+IKITqFszsLmevcCsgCYHGD77mHirlzysXrPgaBRWLuYmQuzebfYnc22LYgn9p7I6THLXgRw3bDAbc3myUkTkyeQzfG4caDjUlEq5QBOxGxfDerZPMNspvOLBS6dOpYlWL4cw4MVp7mFRwS4cDk20IpkdsoMt+tESE90N6AIAsX9ew6Cjhp1a8NDeiLc7vP4kdsMWDsmuHg51vZ5bFsixwuoArGYdA2OL+8G2Nn0cPl6/NiD9Kh6jU1QBWo9XjwQnWZPPu3hCz/xrfjn/24xfMNPVgDkRnpNRKedZbdnMxAWrcuX4wMdfclOWdgtOpHvi5pK0MhmDdrXVzfXPaTSJuaXLKw98prZHIuF19eazZYtcJzobLZjgp0tF2uPvLZs3t7ycPnaGcnmHse5ehX2ROfFSAtcEXkGwBsArKnqyyLeLwB+DsDrAZQBfI+qfvxkr5JGIT1h4uZLE6iUA4gAiWTvMQSuE2Bn24PjKFIpA5mc2Tzj0slxFNubLnLTVvPzlUtB5MQeVSC/7WNxOYbJrIlaNYBhSNs5I9UwgKPm44kAmZwJMdBW3DY+t+Mo8tsepk7ZKqvvK7Y3PewWfViW9Gx8IYK2lXKi0+rJpz2k/vf/EQDwup+shG/8dyO8oFOO2Uy9tGez1JsxReeA44R3Rl1XkUobyGRNZHJmc8RQq1otwPaWi9zUXjb3mjvb2D20eCGGTNZCtRrANKXtjqgGitV7TmQ/DpFwIVyAtuK28bmdmiK/42Fq+pRls6fY2vRQ2g2zOZVmNhP1Muo7uO8C8HYAv9Lj/U8DuFX/79UA/mP9/3QOiAhS6b1tT5Wyj7VHLmrVcFvR9KyJWMwIV3jrAVUqBtja9HH1ehxT0ya2NjwUCnvLv64DrD/2UK1os/mTaniXOKrIbdzVNQxBMtW9BWt70+vZ0Gp61sLMnNUs0qPP6AaYmjnIn0rjYxWl3QBOLUAyZfRdADgI31fceaEK36vfoUX4PJaN5tsaDCNckSc6jZ565uV7Z2iB+l1aGtC7wGymHjqzuVz2sd6SzTOzJuyY4P49ty2btzd8XLkRx9SMie0ND4X8Xna6DrD+qJ7Ny41s1l7j4pvNrgxDkIrI5q1Nr2vUT8PMnIXpWQvlUu9s3i0EmJoe7M+j/WNbs9nsuwBwEL5Xz2a/I5stNN/WYBjhdnKi82yk/wJU9aMicrXPQ94I4Fc07H3+FyKSE5ElVX14IhdIp0a1EuDe7b2tTZ6rWHvowTDQtfrquYrNdRfzSzEkkgGKhfY7tI3mTzO1ALG4gVTa6DnY3fPDoOrVkXBnO7rjswiad4kNQ/oMjt/nC4+6Jldx+/lq25ZqwwQuXY0hkTjaGIOdLa+rkA2fMxxv0OyiXO/UyCYWdFo89czLAbQ0huI52kNjNtOgKpUAKx3Z/LhHNrtePZsXY4gnA0ghYuRQ3sfsXAA7ZiCdNqEa0Y8DgOsFcJwAsVh0Nud7ZDMEzbvEhiE9C+hBmmZ1XVM9m/c6TXswTODy1RjiR8zmrU2vq5AFAM8Ld4o1uiinJwzML9qHmpZANE5O+xLPMoCVlt+v1t/GED1nHj+IPrfTeW62oVgMML9U337ca5RANSxcTVNgmOEdyk6VkuLOCzVcuBSLnIHXb+xc+NovbHhhWQI3ohmE4yhcV2Hbg4fRvTvVrq878IG7LzjIZE0sLtuHXjGOatoBhCvCmZyJxR5jFYhOWuMcLYDwLC0L2pPEbCYAB8zm+p3R+cXe2QwBqhWFHQNMS2Aa4R3KTpWS4s7z/bK5R3Mp7OV2IikwTcCLuFbXUXiuwjpANq/crnaNUQp84M4LDrI5EwsXDp/NvcYnGgaQmzJ7jjwiOq9Oe4Eb9ZMg8qeWiLwVwFsBYMFOHuc10QlznADVAzZMaPSGiMV6j/lpjBlQ1cjitvlYBR6uOrj50kRXOGUyRjhrtrPLcssYAxHBxSsx3Ltd6wpqp6a4d7uK67f2PncQBNjZ8lEpB0gkDeSmread0iBQuNGvJwCEd6aTKUHukGeHwmuObsjBcUB0Grz7F9+CT76v3hCK52hHhdlMcGrBgRsNSv2Ga8wWlHo8plFUBoFGFrcNqsDD+w5uvqQ7myez4Rz4zr+Vti3Nzx9mcxwrEdlcqyru3a7h2q14ezZv+qhUurPZ9xVu9M1mAEAh7yOZNg69ddiyBLVe2cy7tURdTnuBuwrgUsvvLwJ4EPVAVX0ngHcCwEuTObaPO+NUtTmeprTbJ+EihNuDwxXd3LQVXYBagmTqYC36qxVFMtUeJNNzNnZ3A7iOhmd5Jfxv6WJ7J8dY3MDUrInNte5r8f2wmcbEpIlaLcDdF2rNx+wWA2ysebh0LRaeM9rnb7ZquG36sAXu1IyF0q7TdY2xuBx5pAHRQT31zMshX/H1e42hAOB9o7seamI2n1Oqiko5zLwjZfOMFXnEx7b3RvANdLOz3s2/dWwfAMzM2dgtBvA8hQbt2dwqHjcwNWNiY637a/F8RbkUID1holb1cedFp5nBjWy+fC2GZMqEBv3/aquGPTsOW+BOzVgol6KzudcRKqLz7LQXuO8D8MMi8hsIG1jkecbnbFMNV2QNQc8zIr6vWLlTa46n6bcNOJEEfF/gedrcejSRMZGbDv9q2zEDF6/E8HDVaa7QJpKCCxf3VmVFBJNZA8V870Hzqnsrz61MU3D1ehzFoo9yKYAdE2RzVuQQetfp8bUomtuXV+7UIh9z/164Sj3IuZpe27YHkUqbmFu0sP7IazbfiMUFFy8Pedo9UQ+NmbSfbMyjfQ+bQ51CzOYxM3A2366Fs1e1fzYnUwLPQ1s2T2ZM5OqNCWMxA8uXY3h0vzWbDVxoWRwWEUxmDBQLh8zmG3HsFnyUywFiMUGmTzZHf/LWbHYiF5jvrzi48UQClr1/kdm5ffkg0hMm5hYsrD9mNhMNYtRjgn4dwOsAzIrIKoCfBmADgKq+A8AHEI4heB7hKILvHc2V0jCUSz4ePXDhuWFnxHTawNLF7tm2aw9d1HrMd+u0uBxDLGagUg5XahMJo2s1M5U2cf2JBDxXIYZEBtz8oo1ivtbzeSxLEI9Hh74YgkzWQibb/1qTKQOFnehzNImEAccJem6VDvzwTFAsLpidj15tBsIV6snM0VZzp6ZtZHMWavXRC1wdpuPy5NPhX3jOpD1dmM3nS7nk49F9N7zbCWBiwsDicnc2P35Qz+YBLF6IwY7JXjYnja6GUOmJMJtdV2H0yuYlG8VCn2y2pedRJMMIi9rMPj9OkikDhXyfbK4FPbdK+15YBMdigpk5E5vr/bL5aI2mpmZsZKeYzUSDGHUX5e/Y5/0K4J+e0OXQMXKcAKt327fXlHYDrN6t4cr1RPNtqu2FwCMAACAASURBVNrsBthPIyzi8TAwWkcWRD9eYPcIQQCwLAO5aTOy86IIsHwldujmEA2TGROb6x7clqHzIqiP+ZGBXzjMzMVgmi7WHnttK8IiYdhPzx59dl+vsUhER9WYSdu27ZhnaU8VZvP54dS6s3m32Ceb9yESnn9tFF+DZHOvAhUIszk7ZUYuDhsGcPHyELI5a2Jj3YPnRmWzgWplsFuvs/NhNq+vRWfz1OzRX3Izm4kGc9q3KNOY2Nn0IldHa1VFtRogkWgZ0N6nzrNsaXYNbGxDHpb5RRtQIN8yhD6TNbBw4egBCoTBdOVaHBvrLooFHwJBdsrE9Gw4siAeR+RMvvBj0Vag56Zt5KZtuE6AnW0PrgOkJgxksiYM4+jXSjRMnElLdDpt9cnmWjVAPDHYXcJmNk/vbUMeloXFcNG20JLN2ZyB+aXhZfPV63Gsr7nYLfoQEeRyYTYDQDwhfbO59c701IyNqRkbjhNgZ8uD54ajeyaZzUQnigUunYiaE121ioRbbxOJxu8FqZSBcsSA9vSEgYtX2s+buE4AzwficTlyeIgIFi7EMLeo8D2FZQnkAJ9TVftugwbCTsQLSzEsLEU//9JFGw9Wulsx9rqDbMcMzC1wPACdHo15tH977ebetmOO8CE6ldx+2ewq4i3ZnEwKKpXux09MGli+3J3Nvh+eEz1yNhuCxQsxzC8ofD8c3XOQwraRzYYhPacBmFb4HJHPL4LFCxYe3u8+Q3TxSvTHxGIG5heZzUSjwgKXTkQqZaASMfdOFUgk2gNn4YKNu7dr0ADNzsSGASws7W299T3F/RUH1UrQXFmdm7cwNaTtuUafLVNRSrt+W7OMZCo8X9yr0O1lMmPh6g3BxpoHp6aIJwXzizYsi2dt6PRqzKTlPFqisyWZCntYRGVz593bheUY7r0YNkJszeb5lmz2PMWDzmxetDB1yM7+rQxTBmq02KpU9PHwgYPgiNmcydmIJQxs1rM5kTIwt2Axm4lOKRa4dCJyUxa2N722Rg2Nc7R2R+OJWNzA9ZsJ5Hc81KphkZfNWW0NLx6sOKjU7/I2gnl9zUMsYSA9cbLnU5xagPv32s8wlUsBVu/UcOVG/MBbqOIJE8uXecaGTreubcc8R0t05oSj9DxoZzZnTdh2e3bF4wau30pgZ8eDUx/Nkxkkmx95iMVOPptr1QD3VyKy+W4NV28ken9gDwlmM9GZwQKXhsqpBdhY91AthyNzZuYspNImtre9ri6EU9MmZhfCVV1VRa2mCIKwE7Jp9W6W5LqKSkTTB1Vga8M78RDd7nGGyXE0cj4f0Vn02k//GD6+cZvbjonOoK5snreQSpnY2fKadzcbpmZMzM73zuaZXtnsBJENmUaWzVs9srnW3fuDiM6O1376x8JfyO/1fAwLXBqaWi3A3Rdrze6BrquolB1MzZjY3uzuvlgsBJhdqHdxvOeE51clbKC8sGT3HIjue9qz4YPnDdaJeJgct/8ZpkTyaJ/f98PP3zmygei4vfsX3wIA4Uzan6wAWBztBRHRgdWqQfPYD1DP5jsOpqZNbG/1yOb5vQ7LnreXzYtLNjI9stnzezdK9EeQzf3OF3uuAge/iduG2Ux0Mp565uX4Z+7LALS+HumPBS4Nzfojt2uQuSqwvRk9X87zFNVKgAcrDjxv7/FAOG8vnjAiV1hjcek5RSidPvkV2VS6z/ni5OGvx3UCPLzvNrd7xROCpYsxxDn7jo7Bk097SL75le3bjt83uushouFYe9wjm7d6ZLMb3uF8cK87mx/Vszmqu3I8LtFTECTs8n/SUune54uPcvfWcQI8XHVQrTfcSiQFS8sxzqUlGpInnw5/8Lze+JHwDYfYMcYCl4Ymatsw0HvsjwhQKQcIIj5MFdjZ8iK7GhqGYG7Bwvqj9u1HpomhzIA9qNyUhZ1Nr/lCAAi/tkyu+wzToDRQ3Ltda/uctWr4thu3EgdutDEsqoogCBuLDGM8A40Wtx0Tjb9qxFQCYJ9sLvXJ5m0PC0t9svlxRzYbo8vm7S0Pfkc2Z6dMWIfM5iBQ3Hux1nbkqloJs/n6E4mRjQJiNtNZ99QzL4d8xdfjdUMaI8gCl4bGsgSOP/g2JFX07WTYb7vx1LSNWMzA1oYHz1OkJwxMz9iHDq2jME3BlRsJbK652C0GMMyjzwLc3e3x4iIACnl/KDOAVbXZCXO/QFRVbG962Fz3miE6M2dhasZimJ4xb/vGf7L3G247Jhp7piUIemzXjaL1j+n1EV6PYzlAOAc2Fu/I5ln7wF2Lh8G0BFevJ7Cx7qJUz+apaRPZo2Rz0UcQ8eUHAVDM+0f63A0HzeatTQ9bjWw2gdk5C1MzJ7+gQHRQiQ+/qX2B/T3DKW4BFrg0RDOzFh49cNtWbsNOyQZqNYVT0+b7RMLRAqkJE6rdc19FgInJ/g0p0hPmUJtWeJ6iUg5gGOHWpoMUbpYVztBdGNK1uE7v1XPXjV6NP4hi3sPaY68+GzCcMZyaMJBOd3e1BsIV+421vVX5IAA21jyIgaGMf6DjETmTlojOlelZE2sPva5szmRNVCoBXKc9mxcWbaTTJtArmzMnnM31xpKmGY75OVA2273n2x6G62jXdm8gzGbHOXo2F/Ie1luzedJAKm0gPWFF7gjb2fKw2ZrNPrD+OMzm3BSzmU6XxmuS5lGoY5y+wAKXhmYya8J1FZvrHiAANCxSFy6EP2QLeR+7BR+WJchNW83zqdkpEzstjS5EADsmyGRPruPixpqLrQ0PjdwUA7h0JR55zugkJJIGxEBXkIoBJJJH+3Mp7fp4eN9tK1aLhQDFQgARD1MzFuYW2oNxc727G6Vq+HYWuKdL4sNvAgDOpCUiAEA2Z8Fz0cw41XBEX2N+bWHHx27Rh2ULclMt2ZwzsLO9F0IiYQ+MyX0K3GFqZDPq2WwawMWr8ZH1ojjubH7Umc35AMV8mM3Ts1azu3VD72z2WeDSqTCq1yQscCmS1n9iHmSlVEQwM2djasaC6ygsS2C2bEvKTVld23a3Nlzkt/22zovZnIm5RfvEzrKUdn1sbXjN4fUAgABYvRueqTnOLbhBoM0mUqmUAal/zcmUgXhcUKvuraxDANsSTEweLdg31tyeZ68a4xx2trzmSv3cvN12hqlVr7fTyWqbSct5tERjSwMFBti62kpEMDtvY3q2RzZPW13HXjbXXeR3gvZsnjIxtzCabG7sl/YC4P5dB9duHXzG/EH0yuZU2kAsJl070mx7CNn8uH82b6572N706jvjTMzMW13jFxv6bSMnOm5tR6FG9JqEBS4BCAvaUjHA9paHajVA4O8Ne19YOligGYYgntj/8dVK0LbttaGQ9zG3eHIrjzvb0bPygiBsHpFMHU+I7hZ9PFx1AITZLQAuXIohPWFCRHDpahybay7yeR/Q8HsxO28fOdR7jU5o1dgend/2US4FsG3A7d6tBjvG87cnrTH/jc2hiMafqmK3ns21Snh0pbG9eP6YsrlS9iPvDBZ2fMwvnFw295ox73nHO2N+t+jjwaqD1s++fDmGVDrM5stX49hYd1HIh9VlJmNiZgjZ7Bwgm3d2fJRKASwb8CKyOcZsphPSaA4FYGgNooaBBS5BVfFw1UWx6KO1q4Rq2DTBcxWXrsaH/ry9CksFUC4F+57BHZbOIfdt74vqJhHxmNJuAN/T8M7rANuaPVfxYMVp+/oVwP17Dm68JAHTlLAj5WIMc0M+OhlLhGONBuV5ilx9G3nnGa75Y1qIOEiTjfOiMZP2bc0A4ZlaonGmGubEbjHoeHu4EOx6iktXhp/N+e3o8UEAUC4HQz1f209UHwogzIWBs7kYwPcVybQx0LZmtyWbW59h9Z6DG0/Us9kUzC/GMD/kH8HxhNG8a7wvDbM5mzO7vl8iOLabBMxmAsJtx7/8XDhI+m3vyQ21OdSwsMAlVMoBdjuK2wbV8P21WjD0My+9wit838ltr5nI9J6Vl9xnjm2tGuDenRrQsr15MmNicbn/am5j5TdKcUhdknuZm7ewcsfp+QKmU+Os0fKlGNbXXDiOIhYTzM3bSB/DIsTOlouNNQ++X+8IOWshd466NTfmv3EmLdH5Vi4FKO32HvFTKQVwasHQ56/6fbN5qE/V12TGQLVyuBnz1UqAlbu1tu3NmWzYE6RvNu940d2jFdgtDKdLci+z8xZW7x4smw0j3Pm18diF49azecE+lkWI7S0Xm/VsNs1wkkJu+vxk83nVeE0CtMylPQNHoVjgEkrF3qu1QLhS59YU8T4LxUGg8D2FacnAW6YmMyZ2CxHPrUAqfXJNLLI5C4VtH7WuLs9W33mzqor795yuO8DFgo/0hIFMrvc/L9/vDu3wcx5/cR9PGEgkB18pFgFiMQPpSfNYCtpW+W0Pa486OkKuhQ1GxnnsQWMeLQC8ntuOiQjhVtn9stlxFLEhZ3MmY0a+LlANz6CelOyUhfyO33Xedb9jU2E217qyuZD3kZowkMn2zuYg0OjFfhx/cZ9IHjyb7ZiBiUnz2He87Wy7WG/JZr/RrVmAHBtNjqXG65LXn9EJDCxwqW8RB4ShFutxbkc17Jq8tek1Q2FqxsLs/P6rehP19vflUtAWXnML1onOzDMMweVrcRQKYZdn02rvJNmLU9PIWb2qwNojF76vyOaii+T0pIntze4XECJAasgrr0Gg2C2GW80TSQP5HQ/VSneAxhPhWZ7OphWNs9gnYaNft+YxLHCbjRg4j5aIOpgDZHM8vk82b+zdfZmetTAzN0A2Zwwktw1UKkFzB0+47dXa95qGqZHNxdZsnraQ2OcYUK2qkXeh27I52yObJ3pkM4Zf3LdmczJlhD1QIrI5kQQcp/s4lRjhYsRJ2Izol6IaZjYL3PHR1hzqjL8uYYFLyGTNyIYSQBhq6QkDsYjZqEA4g63Z5bBue9ODYQAzc/1/6IkIli/HUCoGKBZ8GEa4YrtfYXkQquH8XcNA5HzX5rUYgmzOQrbPXdfuz422DpOtGqubm+serlyPdz13Mhmuurau0Dcah+wX3gfh1ALcu11DoOF2pl7XCwBBILhyI45H9x2U62d0E0nB4nLsxF7U9Or86Pvh9/KsboVqzH4D0L7tmIioh0zO7MrXhsas+F65tr3Znc1bG2E2T8/un80Xr8SwW89m85iyuVZTmCZg270/r3HYbEbkjVj4HrD+KJwde+VGvOu5kykD6QkDpd32hfdMzhzq2MBaLcDKoNnsC65ej+Hhfbd5dzeRFCwtx/a9QTEsXp9JCmc5m8+zcX9dwgKXYMcMLC7beHQ/bMXX+CFrGOH4gNm53n9NNiPCVxXY2vT2LXCBMEgnMua+g+MPo5D38PiBG4acAvGEYPlSHFbEsPTDiCcE6POpVMPC7PFDFxc7GoGICJYu2tgtmsjveBCELyDSE8NdIX6w4rTdke233c33FLYddm8OgnBL2Emu1gNh58eoTpKWLWcyQBvz3772jG7xIaLRicUMLFyw8fhBdzZPzYR3Y3uJKowbY+D2K3CBMKMmM+axzLwt7Hh4/PD4snm/7sqNbF576GL5cnc2X7gUw24hCLNZRp/Nnq+wYwYuX4sj8MMHnlRh22DHJHICg31Gs/k8Oy+vS1jgEgAgk7UwMWGGd+4k3IozyHmdXnNQgxHfcatWg7aB6UA48mflbg1Xbwxnfp6I4MLFGO7fc5pBHaVXk5DjfAEBhHdDBxk70JBM7QX4Sc057DS3aHd1lxYJG2OdFadh/hsRjYdszsLkZJjNIkBygGxW1Z7zUXu9/aRUKwEePejO5tW7NVy9mRjKczSzeaV/w6a+2Zw1j+1ojusEA43ra0i1ZvMJF7YNcwsWHq66Xdk8u3B2svk8O4+vS/g3k5oMUw58JzUeF9RqEat6sdGu6u30mJ/nOsOdn5eeMHHtVgKFHQ8ba9HV/qj+GLRXxR1BDGDuBOcb9jIxae51hHTCO8qzC/axLQIcVWMm7Wma/UZE4+Wg2SwiPXfDxHqc2T0pvWbbOo6iWg2GdkQnPWni2q048tseNtd7VPUjy+bBGQYwewqyeTJjQS4J1h+7cB2FXZ+kcBy77+ho+LokxAKXjmRu0Q7vYHas6i0MOIMtnCHro1ZViCjiCRPpCePIxbHb4yynCCIbQx2FbQtm5mw4Ne0e/3OCDZo6WZbAsiO2FQmQyRrwvfBFRTJpYGbOGuqoiXLJx86WjyBQTGZMZLImZMC7wifREfIoGvNogdaZtEREp8f8UnQ2Dzq7PPAVpdJeNieSJlLp481mf+jZbGB2PgbHcVDsyOZGz4tRsG2BZUnXn0XY0LElm1P1bO7TP+Sg2rI5ayKTGZ9sPs/4uqQbC1w6kvSEiUtXY1hf8+BUw3l8s/PWQGN+CnmvaxsxxEcsJrh8NQ7zCJ2U0xO9Z9sOs1FGq/klG7VqAMetjxmQ8EzpoC8ohq2xTWvlTjgLUDW8UxuLCRaWYse2DXlj3cHm2t6LidJugJ1tD5evxgcO0tOiMf+tOfsN4DxaIjr10hMmLl6JYWPNa87KHUo2X4sfqTdDeqLPbNshNnFqtbAYZrPbyGaEd7LnR3RntHHO98Szec1pu5td2g2Q3/Jw6dpwjm3RyWi8Lkm++ZV7zaH4uqQLC1w6smTKxOWrB1vVc13tDlAA0HD8ztojF0sXY4e+puyUhe0tH77XPj9vato8thFEphl2Ia6UAzg1RSwuSKaOvuJ9FImkgetPJFDI+/DcAImkiYnJ47sm1wnaituGakVRKPgH6oQ5Ko0GDADO7Pw3IqJU2sTlawfMZqe7fwWAZjavP3KxuHz4bM5NW9jZ8uD5aBabImHTrKMsavdjWoKrpzWbd3x4XoBkaji713qp1YLIrdqViqJY8PvOBqbTofHapPm65D0jvJgzgH+jaSSKea/vOZRiwcfSET6/aQquXo9ja9PFbjEIRyPM2JjIHO+QehFBKm0ilT7WpzkQ0xRMTQ//n7qqolIJEPjh2CPTEjx+6PZ8fPEUF7jnsQEDEVGnQr57BmyrYsHH4vLhP79pCq7eSGBro57NlmB6xsLE5DnN5pljyuZygCAIm0eapmCtbzYHyGSHfhk0BHxtcnin89UmjT3f14N1WjgE0xLMLcQwt3C8z3MeObUAK3dq8IP6vEEFZuYtVCKG1Declt3J4z77jYjosHy/fzD3K34HZVqCucUY5rhBZuhqtQCrd2oI6lGsCszOW6j2y2bjmF+M0UAar03+9tpN/HPuHjsyFrg0EulJE9ubvVeKj3s197BcMXE7fRElK4n52hYuVNZG1YhxZFQVK3ed5uD3xrdwc82D0efblpka3Y+bxIffhF9+LhxB8bb35EZ2HUREp9nEpImdrT7ZfEq75rZm80J1E0vV9XOZzat3as1sbthY8yB9svm07qw6D9qaQ/G1yVCN9G+1iHwDgJ8DYAL4v1X133a8/3UAfhfA7fqbfkdV/9cTvUjaVxDUB48f4BZdMmlgImNit9AdpJYFzC8e/ozPcdm2J/G7y1+HQAx4YsJUH7O1bXzjwz+Gpb1XR8dJrRogv+1HdqJWBQwzes6iZQMTEyf7wohbe4gOh9k8HgJfATlgNqcMpCcNlIrdjaAse3RNE/vZsjN43/LfbcvmuWqYzSbOTzbvbNfPNndQBSwT4V3dju+pbWOgxmM0PE8983I2hzoBIytwRcQE8AsAvh7AKoC/FpH3qernOh76J6r6hhO/QNqXU29GUSmHAZJMGVhatmEP0NJeRLC0bKOUNZHf9uB5CtsSpCcNTGatY+sieBR/tPBa1AwbjaVQTwysx6fxqexL8Mqdz4/46o6XquLxA3ff81mWJTBNoFYNm3uJhHP8Ll2Nw/fDc0GGgaE3+GjMfQNOePabKlJFB5mtKiQIUJmIoTCTRGCezh0IRPthNp99Ti3Aw/sOqpXwh3UqbWBx2YZtD5bNFy7GsFsMkN/x4J+BbP7g4mtRM2LNofOeGFhPTOPT2Vt4Mv/siK/ueKmGDTuLETcLWtm2wDDC8UMa7GXzxatx+F7YT+M4snlUFMDzE5fxmewtOEYM10or+LKdZxEPep9FPi5dc2nZHOpEjPIO7qsAPK+qLwKAiPwGgDcC6AxROoWCQHHvxVrb3bpKOcDd2zVcv5UYKARF5MzMVSuZCeTtSXTu8/ENC89OXhv7Ane3GOxb3IoAkxkTuWkL5VKAaiWAHQu/x/ltD+uPPYiEwWMYwKUrccSPMBaibdvxiOa+5dbKmNyponGEydqqIl1w8OBaFsoil84mZvMZFviKe7fbs7lcCnDvxRquP5EYqHgREUxmTEye0u3IrYpWCkUr3SxuGzzDwrOZ62Nf4BYL/r7FbThf10I2Z3Zl886WF25hrmezaQAXj5jNp8GfzTyJL2SuwzPCHQeftF6K5yeu4M0rfwBbvX0++ugaW48/+b4cwLm0IzHKAncZwErL71cBvDricU+JyCcBPADw46r62ZO4OOqvWPARRPxADQJgt3j4lvPVSoDdoodABdmMifgxzaw9uD4vCs7+Yue+8tvevgEaiwuyUxZEBOkJE+n6luRKOcD6Y6857w8A/ABYuVvDjQFfcDXmvgEtM2n7bDtOFwq4/NzzEFXcu3UTu7nht4g0vACZnSqk5c/FAAA/wMRODcWZ5NCfk+gEMJvPsELBbzYYauUH4ULlYYvWRjarCjJZ80wUQOehdVJ+e//iNhYPv2ed2Vwu+9hYa89mLwBW7w6+GHJQrhNgtxhAAUxOGgPt+DuokpnE5zM34Rt7f9cDw0QFCXxh8hq+tPDFoT5f4/XJF37iW/eaQ3Hr8ciNssCN+pfT+c/04wCuqOquiLwewHsB3Ir8ZCJvBfBWAFiw+cLyODlOgHIpQNSxUw0A1zl4rKgqHj90kd/eW3be3vAQTwguXT3aYPlhSPsVTHq72LEzbSvFZuDhVuHO6C7shPQL0EQyLGwzWTPyzv1Oj+I4CMLit9f5n6eeeTn+9tpNAAebR3vrE5/Eqz704eZPk1d89E/wt1/9lfjcq75i4M8xiHjVgwraClwAMBRIlhwWuHRWMZvPKMcJUClFFzxhNgcIj1UPrnE8Jb+zl81b9Wy+fDUOY8TZPOGVkfYqKNgTXdn8RPF2n48cD/tlc27KwmSvbO7RTGy/bD6s7U0X64/3Fqs3HgNz8xamZod7rnstPg1Dffgdf9c9w8JqamEoBe6TT3vtBS3AXh+nzCgL3FUAl1p+fxHhSnCTqhZafv0BEfkPIjKrqhudn0xV3wngnQDw0mTuPCzcnTjPU9y/V0Ot2m+5MPzhuPbQgR0TZHIWTFNQrQQo5MNCZzJjdp3zKJeCtuK2oVZVPLhXw6VrieP4kg7k7z3+c7z/wt+FLwJPLNjqIecU8GVjtAXK8xSqCsuStu9PJmeiUu5uOmIYwOWrcUifLen9xk5ENaRqNoc6xDmVVLGIV/2/H4bV8Ylf8bE/w+qNGyjMTB/8k/bgW0bkLQIF4Nmnf2sfUQ/M5jNmoGxG+LO4M5srlQDFnXAufSZrIplq/9lV3g3aituGWlVxf8XBpavxYX4pByYAvv7xn+H9F7622WTKVg/TtTxenh/unbpR6pXN2ZyJaqVHNl+L970LG/TJ5qhdAEfhOns7uVqtr3lIZ0zEhngnN+VXoRFft2iACa986M/b1hwKYEF7yo2ywP1rALdE5BqA+wC+HcBbWh8gIosAHquqisirEO4A3DzxKyUAwP17tWbTil4EwPam12wwtLHmYTJrorCzt1KY3/aRnTKxsLTXKbmQj6h06splhesqbPv4V4rvpRbxucwNOIaNG7sreEnxdrND8oyTx1vuvh8vTlzCrpXCfG0Tl8qPum531AwbJSuFCbeE2Amc9RgGz1U8WHWas/JMK2wC1ljBzWRNFPN+eOdeAUj4vV66GOtb3ALhgkZ5tzuARYCv+aUvRTxrDW0e7eXnvhh5/0mCAFeeew6ffuo1Q3keAHDiJjzbhO34bU+pAhSnRr8gQ3RIzOYzZvXu/sUtBM3RfM1szphtvRWisjnfL5tLATxXYR1zNiuAe6klfC5zA65h4WbxHl5SvNPskDzr7OC/vft+vDBxuTkm6GKldzZPuqUTOYc5DK6reLhSQ7X+/bUsweJFG6n6QkQmF34PGwvQjbruwqXYvluMJzLmXqa3UA2bTQ1TseBHbhlXDd83Mzu855uvbWLCqyBvmdCW2YWmBnhZ/vmBP09jF1nzLi2bQ50pIytwVdUTkR8G8AcI98w8o6qfFZF/XH//OwB8C4AfEhEPQAXAt6sOY8w4HZTjBH0D1DTDUTBObW/LTONcR+ed2cbbsrkAiQHO2Iog7OR4zCH6V1Mvw6dzL4FnhP8s1uMzeHbyGt54/0PNII2ph5fWtz2VzCReSF9CIqjhQmUdAPCns6/Es5PXYCBAAMHL8l/Eq7c+daqP6aoq7t2ptW0t91zF6l0H127GYcfCu+3Ll2MolwKUdn2YZngHYJDvSSYTNrJodFaGAH7cwl899VX4T3/0Xx3DF9T9JlEd/oEsEaxdzmButQi7Fr5YUhFsLqbhJjhXkM4mZvPZ4tQCOLV9stkCarW9H4HNbN45ejZ7/vEXuH85/XJ8Nnuz2TBoPT6D5yav4ZsefAhm/auKqYe/U3wRALBbz+akX8NSdR0K4GOzr8QXW7L5S/PP4VVbnz712bxyuwbX3fv+uq5i9Y6Da7cSsO3wbu7FK+3ZnM1ZA31PMlkT+S0PtZo2X7eJAHML1vEcC+v113TIPzkEwDc++Aj+cPErsRXLQRDA0gBfs/ZXmHILfT+2rTkUC9ozbaSvwlT1AwA+0PG2d7T8+u0A3n7S1zWuyiW/eSc1kzORSg/eDt73wh98US9h4nHB1ZsJvPBspe95kFaqwM62i2TVhGkJMlkDhYhtUA2x+PHGUMlM4FO5l7Y1JfAMC9uxDF6cuIRbu3f3rh1h4H4m+wQMBIACtrq4UnqAL05erGgANgAAIABJREFUhW+YzbMfn83eQtKv4svyzx3r9R9FpRz0nGu7s+1hbiFcze9sUAGEhfDWpovSbgDLEszMWW3ndhrNF/5n/VFc/fwXcPXZZ+HEk3j2FV+G9eULg12gKhZW7yO3sYH89BQeXb7c1TGzYeXGDXz5R/646+2BaeLeE5FHBI/Etww8upqF6fowAoUbM5vXJoEiVajBdnw4CQvliRhwCkdsEHViNp+sZjYjLDoOks2er72zOSG4eiOB558dvItrWOR6qFWNZjYX+9zFjcWO92da0UrhM9knurJ5M57FnfRF3Cjt9UNTAH8+8yQ+l7kZZjOAmO/gUvkRnp+80pbNn8k+gbRXwcsKg9/RO2mVcgAvYhuxIvwezc6HBX/PbN5wUSoFsG3B9KzVdabWMASXrsVRzIedmE1TkJu2Br57qxqO/qvVFPG49B0xlJ40sLHW/fe0MX1h2Cb8Ct50/49QtFJwDRs5pwCjXkm7YuGFiUuIvySNy4ktJH76NfgXP8vmUOOGtxnOifVHDrZbGgoUCz4msyYWL9gDBWk8IdHFq4Q/uMJfCw6yFJffDlDYCZq1SnpCUNpt/3gRYGau9+y9xk2Do3b7e5icg4EgoimBjbuppbYC927qAj6bvdkWlq6a+HzmRuSogk/lXnqsBe6OPYnHiRmkvQouVNaaP8QH5bm9H+/0aRjmuYo7L1Sb52idmqJSdvDUL34jXvL9r+iaR/viy74EL77sSw50bXathr//7t9CdnMLogoVwW4mgz94y7ehlmxvWGPVHHzN+/8L0HGz1rdMfOo1r0J+duZAz30Qvm2i9SWg5fhYvJuH+AoD4fWoAJuLaZSzEduXVZEuOJjcrsDwFeVJztMlOg/WHjltzX6KeR+ZrInF5Vj/D6xLxI3IbBZBs+A5aDrubPuQHb8ZZ6kJQTkim2fnTyCbE3MQ7W6O5Rk27qaX2grc2+mL+Hzmens2i4kvZK5HZvMnci891gJ3257EWmIGaa+M5cragb8Prttj55H2b+bp1rM5aMnmcsnBwpKN7FT7y37DCJtEdr59P76vWLlTC18j1HdmxeywYO68++v7ioerbmRxOzNnIRY/vpyb7Dhze+HrEvg/tv4bFAoBjO16Nv8QkFqqoZyJOE+uinShhsmtKoyA2XyWsMA9B5xa0FbcAvVzD3kfuanuphJRDEMwt2hh/ZHXtpXFNIGpmXAVMZszsbXRf5xMp9b29E4NWL5sY2Pdg+uEW5Jn5uzI1b3AV6w9cpvnh5IpAwtL9qFHF8R9B9EdgxRriRnUDLs5IPyz2VvNrVJNYvRsZ1g1BnuhclABBB+efxVupy9CoBAF4oGDb37woa4f6v0kktHNkkSAVJ+V3M0Nt6tJlCrwkR/+IH7oCzfDfXFH9Mo//iim1tdh+nsdLzLb23j1B/8IH/3mb2p77Fd8+COYXluD2dIdwxfByvXr+PRrnzrytRzE9MNdGL42X9AIwm7Lsw9L2Pa0q8Py1FoJEzu15jzdSc7TJRp7tVrQ1clWNexJkZsebJuwYQrm5i2sr3Vn8/RM+DM4k7OavTEG1ZrNrlPP5jUPrquI2YKZeTtyhn1kNl+wET9kERMPnOjCUBWP47NwxGr2uvhM5ubBstk8ngZZAQQfmn817qSXw2wGkPBr+Ob7H8KEP/jd9F7ffxEgme6Tzetus7htUAXWHrnI5MyhjP/5/9l7zyDJrvNM8znXpXflXftuoOFJigQBkBQBwdCLXA7F0UihmdFqViEzo9kVJ2YV3IiN2H87E4qdnR8TKyl2GTIraailEzUUCYIUSIoEQYAGYAOEa4fu8jYrfV539sfNzMqsvGmqukxW930iEOjKSnOz0rz3O+f73ndl0aJabSrAJVSrXhrG1EzrOc/yQu2624glFIZH99ZB2Y9mc6jxNzcJlW3qf72GNs8XWLddCkOt2jy0VCS22arN0bzJwsk08pAdxAO6ExS4twDFgr8dnpReZm0/BS5AZkjHMBQ21mxsSxJLKGSGdTTN+5APjWiNEPHagt6OBNW2JZqucPJ0b4Oe2Wtmi3NgueRy7UqVU2fDu5oHmi4vo7kOlpCtK71CUFQjPDX+EB9e8FpfTWVnH5vR6saOj6cfXk2c4mpsBqfpeGxF5anxd/Hxuaf6vh8jpBBPqhS2hcWrmjfLs5162/GffCZJCv/nllrfYGNstO9j6MTpn73aUtwCqK7L8dcv0uKoAZz+2Svt15WSY5ev3PBx7AhXEi7bvidlAkivlihkwsjazodquS3FLQR5ugEBtwLFfIdIn5o291PgAmRGdIxwTZttSSyuMjSsoda0eXhUo1xyqNR8EHaszZZE1xVOnumtzddrhlct2ny5yqlz4ca5wk6YKS2iSgdLam3aXNCiPDX+EB9a/A4A1vbitgdj1fUdH08//Cx5hjdj063aLFS+MfEQH5v7Zt/3EwopxBIKxXyTEZTwjKaSqc7nbaVO53x4u7mh8I0XZrlNx3dh3DuPkI0iWkpJPud/3U7npjdK/Rzlg8rveRfUZmmFKwl10ebMSoliulmbnZbiFmrabLvENittxXDAYBEUuLcAootGdmov6sT2OY/t93XspEG57NbcliUri/07FQqBb7budioV19cWvz4zWp9L2QkKkg/Pf4svzDzutTY1CamrqCyGR8hrURJ2idOF66wZ6Rbx8kVKNOnw4NpPdnw8/eCZbrQegxQK60aKghrZ0Urx5LRONiLIrju4LiSS3spqPeOwzU0QeCL2WVLr7QWu4jhUonvzxa90yCoQUjZalpsf1/c+Oly+b/T6SAnQqzZmxHufGrU83e0nAIqEcMkKCtyAgJsURRH+87PCi3nZCb21OeTNS1Ykcjfa3EdBXCm7LcVtnfpc725261QkH174Fl+cfsxXmxciYw29O1O4zoaR3IE2v7Dj4+mHTtq8amQoqWGiTqXv+5qaMdhYs8luOEgXEimF4RG967mbqoFl+fxC0lj0uFE6+kV1WLDZ0Z3sgocufIofr15pzaXdKYKGZwZ42kwHbY6UrKDAHXCCAvcWIJFQWV5o/7YTgq6rgLtBCEE0qhKNej/nN52e0ULNhPtYWbSq0vdLR0qv+N0tQ1aOjJljNdyelapK14sXsEvcmbvEG4mTbOpxrx2quS+s9Yj44Py3GN+nVWJb+H98BdIz5OhS1xULDqtLFqYpMUKC0XGdzLDeaDcHCD/98a72+C/f/w5GFhfRra0TJUdRWDo2Qzke39Vz2s7s6VMcf+MiSpNCukKwePxYi/0/wMLJE0xefbPtuvMnT+zJsfSNEFRiOuGi1aG1rpahW8PRFITfSQFg6+1nuXrVJrFeQTcdKlGdfCaMq/V3NqxXbIyqg2UonojvQataQEDA7ognVZYXfbQZSOyHNsdUojHv51zW6R0t1HRA/ez6mVW3szaXd6/Nw+YmKavAeijd9jtFOpQ0r8C9K3eR1xMnyevRntr84bmnGTX3p7vKFp1eO4nTbccBb+d+ddnCMj3jppFxnaER779+GRrRWZg1WwtLAdGYsqtddD9iMcV3BzYabzWa8t53CqWiz3W7tFn3w2f/+Fc8t2OAPygD3YtbqQgqUZ1wqYs2N7Udd82619pf40CbB4ugwL0FUDXB1DGD+etmI79UShif0tH3MFzbj5njIRbmTIpFF4E3FzQ2qbO+0m5NPzndnqkqpWRj3WZjzcF1JNGYQiqtdpwZjexyBrfOVHmZdSOFq7R+eTlCIWNuAqBLh/9u9htcTBznWmSShcgoZa19JU937X39kjpTvMaL2vm2Yw25Jkmr0PF2+U2bhbktw4dK2cvAffT/OM+vzn5o64o9QsznzpzmJ+95N2/9zneRioLiOixPTfOdX/zwbp9SG88/+ghjc/PopoluWVi6jqNpPPvE423XffbxR/nQn/8lqm2j2zaWpuFoGs899uieHU+/rE3EmbiaRW2awwXvbVuNaDj61mtmhjvn6Ra25emGiyajs3lEbY3HqNgkshUWTqZa7rMNVzI6lydc2jqZtgyV5ePJwCwjIOCQ0Dpo88SUju6zuLWXHDsRYn7OpFTXZk0wPqmxumxj+mmz8NHmNZuNdU+bY3GFRBdt7rfduhNT5WWyRgJ3W/HoCoW06UW/6NLm43Nf52L8BNejE8yHx6ho7W3V+63NpwvXeXmb8zNAxKkS7+KPkdu0WWzS5nLZi+ubOWG0OSB3I5FUMcc01pbtxu57JKowObN3fiDjkzpvXq7iulvTQooCE5Pthfj4pM6bV6rIbdcd97luJ97yAZvIL72tMUsL7MrxeG0yxuSVTRS3VZtdoBrRt2mzhq0r6KbbM+s+XDAZndudNo/N5giVtzYKLENl6Xgy8N+4QcTNGF13PpKWnzn77t5XvMVwXemtuElvlW1fcs464DgS1/V8h4QQjbkML14GUhkNw6fYXpo32cy2zikpireaXCnLtst3O+dTp6iG+dyx91NVdGRtpVVzbe7LvsrbN172vc1T4w9yOTbT1guuujYfmv8WZS1MzK4wVl3b08y9qqLzxenHKGoRbEVHcR0UJB9Y+A5TlZWOt7v8eqUlV6/O+ugIf/fr/2LHx6FaFunVNcqxKKVkcse374VmWpx65RWGlpbJjoxw+a47sEL+5iB6pcLZl15maGmZ9bFRLt1zN2a499zYviAlmaUi8c1q46JqRGd1Ot5WVCq2y+hc3muJwltpXpuMU44bLfc3fSmLZreuhEugmDRYm0qgmQ7J9TKhso2tKZhhFSukYZQtEtvmfCVQiuuszuz9a3az8e3/8KEfSSnfftjHcdQJtNkf15EUiwOiza4kn3co5l00vbM2L86ZDSOpOoriRfptb1NWVDh9NnxD7bFFNcL/d+x9mNu0+a0bP+Nt2Vd8b/Pk+Lu4Gpvy1eaPzD1NUY8Qs8uMVdf3XJu/MP04JS3cpM0uH1z4DpOVVd/bSCm5/HoF26dzvB73tFNcV2JWJaom+sqs3/H9O5LNTS/jPhQWpFJaY6xpO44t2czWrhvx/D16vc8fuvAp/u0zCwBbO7V7gZRkFgskcmbDL6YS1VmZircVlarlMjKXx6huafPqZJzKdm2+uIG2LdJJAoVUiPXJuKfNa2VCFRtLU7C6aLMLlGqaHtCdbtrctcAVQiSBUSnlpW2X3yul/OneHubeEYjozYFte1/4fm/R9JCCQLCZ9WZGo3GF8Ql9T+zmC2qEH2XuYjY6Qdipcl/2Vc4Ur3cUwOXQEH839UjLzI1wHSJulaoSQpEOUgjidpkPzz9NbAfzN72whcKl+HHmImMkrCLn81c6Oii/5QM2r3zqE7w4+de+z8VRFP7ff/c/7ejxhety3/e+z/mfvIBumqxMTvLco4+wPjG+i2dzkyIletXB1ZSW1mQ/VMtFuBLbUNp2GFTbZerSRosQ1nFUwdLxpBdNtK1LUAoaq8pthwZsjEZQbYkZ0SgljKA1yodBK3ADbQ44TGxLcvkNH20WkBlSkFKQyzq40mtlHZvUfYvknZLXovwocxdzkXEvXz77KmeKsx2vvxga5itTD7drs1OhqoZRpIsUXpTMh+e/taPZ2F7YQuVi/DjzkTGSVoHzuctdfTFcV/LGK/6PLwTcdufO5j2llKwuWw1fjUjUex3CN9jltp+0mUPtN65ENx0cTenZStxVmy2HqctZX222NcHyTE2b5e60uRrVKcf1QJt96KbNHVuUhRCfBP5PYFkIoQP/Ukr5fO3Xfwq8ba8PNCCgGbPqdjS3qJQlJ06HGJvc+8eNO2Xeu/rDvq8/Vl3n4eUf8N3Rn8MWGi6CtJUjpyda8vg2dc/h+GPz/bso9kKTLrfnr3J7/qrv7x+68CmArUza/wS/HA4TqrQLqWUYCNdtm23txkNffZITr72OXlt2Hp+b4/1//Vn+7l/+GvlMZuuKHWehBhO9YqPaLmZY63uGpiNCYIX7mwZxurQluqKzf5WrCDLLpUZxC03/79Gkk14to0hws5BcU1k6kWq4SAYMHoE2Bxw21U7aLKFShuOnDMb3QZsTdomHV57vfcUaE9U13rv8HN8d/Tkcoda0eZOcnmzR5qye4BvjD/KL80/v2bFq0uF8/grn8/25+Nfbdv18FRWFFmfifliYtSg0uXTXkyZOngm1LDbsVV7xbmk7R+lGbbF4z7RZ2Rttloroos0KmeViSyG7c22uYIVUlo4H2rwTur2ynwZ+Tkq5IIS4H/gLIcSnpZRfYOe54QFHiM0Nm9UVuxYNIBgZ10imDn5cW9NFR/e9vVgN3kvOFGc5VZyjoEUxXIuvTL7X30UxlKGohvd0F7eZ5rw3oGa80MpPH7ift3z3mUZRWkczTR793Bf45ic+3leRGy4UOfXqa6jbXIpV2+au537Is+97nHg2y4NPPsXEtetIIbh221l+8PhjVCOD6T6o2C5j13PopgNCIKQklw6RHYsdenEuVYVyTCdcsGh+dVwBuaGwV+B2uz20zQPXMwDBc4bUa21Um6PRvT78gL0j0OZblOyGxdqyjW1zqNqsd9XmwXoLni1e53RxlrwWJeRabd1W4GnzcmiYkhoi6lQ73NP+IoRgaERjbaU9r9hxYO6ayfTx9lloPyxLthS3daQLG6s241MGZtVlacFqmD8lkirjU/qBtMe3m0P1xl+bw2THooeuza6qUI7qRLYZS7q1Wd3McvHGtbnqkFgvkxsJtLlfun0zqlLKBQAp5XNCiEeA/yaEmGFPzb0DBonshs3ywpbJgWVJFucshBAkknvr6tgLw1CIRBXKpdZIICG8zN1BQ0GStIsAmB3y+ASul9XXZ4HrhS0JlA4fuQc/cy/AVlHr43a8nZ+94+2Ei0Xufv5HLV+qmusyNjfP9OUrzJ490/N+khsbOKraVuAqUjK8tIRerfKhv/grjErFczaWkuOvXySzssbf/vf/4tBFyY+R+TxGtWb2VHvTJbJVrLBGMXVIs7xNrE7GGZvN16KFBIqUFFMhCukwqbUKit3dqdTFy/Fz8a+EFAmxXDUocAebQJtvQbLrFsuLdps2K0IQP2htDnXW5syAanOqoc2d0wcsoQH9Fbi9tHk3DI1o2LYku94egVAqupQKLrFE79e6a/dbxcVxJG9eqeI2PUw+52BWXU6cCe3pbm7dHAqazlN2YQ41OuenzRXMsEYp5e/JcZCsTcUZve7N6ta1uZAOUUiHSK2VUOzu75N+tDmeqwYF7g7o9k2UF0Kcqc/41FaLHwa+BNx1EAcXcPCsLlvtq34SVpasAy9wAaaPGSwuWF54OKBrgvEpndAAz5EAnCzO8pJ2W5vDse7apKx8z9tXFZ1/HPk5rsRnkChMVFb4+ZUfkrbyhJ/+OIAX4dNHQduGEOSGh7E1rW0XV7csZi5d6qvAzafTvhmzrhCsj45y+uVXUC2rJbZHdV2iuRwT166xeOKA43t6oNguYZ8QeEVCeqWEGdL6bmfaL6SqsHQihVZ10CynpU0rNxQmvVLynQMCb94nOxIhVHGwNIVUtuJfDg3eukNAK4E232J485TtO3tSwsqydeAFLtS0eX6rDVbXBRPTOqE98MHYT04V53g5ebZNmw3XbCxQd6OiGPzjyM9xNT6DBCbLK/z86g9JdUku6BchRO3v166rUnoRQv0UuEao8w57KKywuWEjfdZCTUtSLrk7cmz2o55JC/DB3Z6nNKHaLkalgzavFrFC6qFrs6sqLJ1MoVdtVKu1hTqXCTfajf2QCmSHIoSqDrYmSGSr/tGBA7gpMMh0e0f8NqAIIe6UUv4MQEqZF0K8H/jlAzm6gANBup6Do227OB2y3y3zcDYGFFUwNWPguhLpem6MhzUrshPemn2Vy/FjVAhjKxpCuqjS5eGV53rWDxL4u6lH2NCTjUiEhegof3XyQ8yfSeP+4Y2fQJjhsG8bsqMoVMP9tQ+XE3Gu3XaO429cRGsqlB1N4+X738EdP/pxWwEN3g5van1j8ApcV7a1CtVRbcnEm5uYYY3lY8lDn4OxQyp2qPUkJJ8Jo1kO8Y1qy6yPxCtuV6cSlBMG9eWVaMlCrzrtLVUDsFMd0JVAm28RXFdSqmtzh1zzQ9XmY0dQmzd+xpXYDGVCOE3a/Mhyf9r85alH2NQTuDVn5oXIKF+cfox/du0rhNz2TOOdoqidZ3H7daHWdYVYQqGY9+l+G9ZYX21fLAFAglmVjazknfLpD/2O948+Mml3gnA6v8c1a7C02QppWNs2lPNDETTLJZ5t1Wa39o/VqQTl+JY2R4p2W2ygKzxH5oD+6VjgSilfBBBCvCSE+AvgPwLh2v/fDvzFgRxhwL4hpaRakcy+WcXtoZH6Ic/VKIqAwV4YbiHsmvzS9Sd5LXGSuegECavIXbmLpPvYvR35395J4a+TuFZTASMFAkksWyU/fOPzq3OnTvquBkpF4dI9/W8Cfe+D76f0j9/lthdeRDct1sbH+cHjj5IbHmJ9fAxL19GtVtGXQpAdGan9IJm+fIVzFy6g2A6X77qTN287R6RUwgyFsY3+c/JuFFtXPHH0EdP6PIxRscksFVmfjB/YcfWNEGyMx9kciaJVbXRLYpQtXFWhkArhGK0F8cp0oubsKBt9UZWITn4oKHAHmUCbb37q2nz9zSq16Y6O7Ef8y044atoccU1+6frXeC15irnIOAmrwN25i33twM6HxyjosZbdXykUHKHyevwE9+Qu3vDxxRMqS7QXykJAMt3/zurktMHqkkV2w9thD0cE45MGRkghFBYdW5hDYe/9JKUXK7m54RXDybRKPKHgOAJVhXf96X0ArZ4f+4Rt9KfN6eUiGxMDqs0TcTZHPW3WLJdQ2cbRFIqpUFtO7sp0golrmwhXNgZyK1G9LXs3oDv97Om/E/gPwDNAAvhL4F37eVAB+4eUkrVVm41V23eF0A8hYGRs8OZqBh1D2tyTu9iX6D34mXv5H627efHLaWJfrzBkF9vOGRRJI4vtRnF0nW988p/w6Oe+2GgzFtLlmfc9QW5oqOttRxYWOHPhZTTL4ur52/nRe3+eHz383q0E9xpX7riDt3z3GVTbbrQpO6rC5lCGpZlpAN7xzac5d+GlRhE89eY13v2VryKF50p45fztPPvEYzj6ARS6wsueHWkKa99OfUZ1feLwTac64aoKZtTABIpdVnxtQ2X2TIZowUS1XaoRDTOsDezzCmgj0OabCCklays2G2s71Obxg1sEvFkwpM09m29wz+YbO7rdppHA9VEGW9HYMFJ7cmyKIpg5YTB7zWyMkEgJE9O9o5bKJYfNrIN0IZFSGZ3QGZs02hyYU2nPzKq5K0AIr7gNR7zHWFqwyGW3jKpKRRdHVWqLGYK//40Czz7xWH9VxI0iBGsTcUbmu2tzfLM6mAVujWZtLnV5u9ih7dqsY0aCc/Cd0s9fzALKQARvlfiKlH7d+wFHgZUlLxet24ow0Fjd03TB6NjhODXerNSz3l7995/05mihZUbFCvmv0roCqn3OmegVm8RGBc1yKMd0CulwW4D52vg43/7IhxheXCKXybBw6mTPHdO7v/8D7vv+syiOgyIlJ15/g7lTJ/n2Rz/SVhjZhs5X/vmv8o5vPs3M5StIRXD5jjv40cM/D0KQXF/ntp9eaGlv3m5YdfK111Ftm+989CN9Pe8bpRw3WDyZIrFeIb5Z9RXSXtb+RwpFUEoGbU9HlECbbyKWFy02N/rX5rqL8mF4Y9yqDJmbCB/jAs21GKlu9HUfq0aal1LnKGhRZkqL3Jm7hCFbF67DEYWpGZ1KWWIYglhC9XbKu93vstXSepzPOcSTKpPTelvruKIKTpwJsbxgUSx4hlSJlMrYuHfdasVtc2GWkhYTw1OvvoriOHz3Ix/q63nfKOWEweKJFIn1MvGcGWhzQE/6OVt+Hvhb4B3AMPDHQohPSCk/sa9HFrDnuK7sq7gFLxR85kR/lvQBvalnvf3bZxb4dN0e/w/9r2uGVMyQhlG1G6YEEi9rrduOXJ1IrsrIQqGx0hkq2yQ3qiycSuHWityhxSUe+9znUW2voFRcl2cff5RL99zd8X6j+Tz3PfN9tKYiVLcspq9cZfLNN1k4ebLtNqVEgm9/7Bd972/yzWv0Mn3VbJvjFy8RKpWoRg/GPdAKaaxPxtFsl/A2238JVKLBLmfAQBBo802C68i+iluAaEzpOy4mYG8Zq6ySMXOsGelGm7KQLrprc65wreftL8Vm+NbYO3GEghQKS+ERXk6d5ROzX2/M75ZLLnPXqo33gpQwPuXtunbCMt22uVopoZBzKGdUX9MoXVeYPt5+PvHQhU/x8n9+jov/7ptoPmZXdTTb4eTrb/BcuYx5QLF/VlhjfSqBZm8SLtk+2hx0MwRs0U+B+xtSyh/W/r0IfFQI8Wv7eEwB+4Rt9be8JQQkU2ogoDdISyZtI+st3fU20VyVzHIJ1XaReLu2AOWYzsZ4rG0Xtg0pGV4strj1KRKwXZJrZbJjMRTb5om/+RyhSmtU0QNPfZO1yYmt+dhtTF25WpuDab1csyyOv36xrcBVbJt7vv8DbvvpBRTX4dq5c/zkPe+mEvMKVTMUqhl1dBZRAEdViRYKB1bg1lkfjzFx1ZtRVaT3WkghWB8f3BaogFuKQJtvEixbbjnCdaG+0xZo88FzMXaMZ0feQlGNoEgX1XUAyYnSPA+uvoAuu48POQi+M/qOlgxeW9EoEeHF1O3cv/ESrlvzRNnWh7E0bxGJKBgdHKqLBf/GDSm9ndztBa7rStZWLK+dWcIrd9/DT97zbk9j/6DMmZcU3qkodHQ2qz8nVSFaLB5YgVtnfTze8I9o0eaJXbpjBdyU9CxwmwS0+bLAxOIIovVhRiGEZ0aQTPXf9uS6EiGOhoNiv0jgUvw4LyXPYSkapwvXuGfzjbZWojr1PFrxjsd5uF7M7tAaP1wwGV4oNIrTustebjjCZp/ZZ7rpeKZB21CAaN4kOxZj6uqbCJ8hL8VxOPvu5wjxAAAgAElEQVTiS/zw0Yd979vWdaRoF1gpBJZhtF3+6Oe/yNjsXGPH9+xPL3D2wkvkMhleeuc7ePO2czzQx3tGcV3y6UzP6+01tqEyfzpNPFvBqNqYIY1COtyw/g8IOEwCbb550DXRV3EbjiiBNgNvxE/wcvIstqJxpqbNvQrMG+FqdIpvj93fKE5doaK5Nm/d+Blvy77S131sGClfY0dXUbkan+H+jZe6FqrZDZuxiXadBRAKHRdItoclPPD/3MPXfvsVljcstFr9eu7FC5z76UtsDg3x0gP3c+3sGd751Dd7PichIZ/am9njnWCHAm0O6E0wWHkLoSiCzLDGxlprK4sQEE8oCCGIJ1TiSaUvQSwWHJYWLCzTE9FUpjbDccg27XvB90bexmuJk9iK1/Kyqce5mDjBP5l9Ck1urWqGn/44f/Z6mE9/vrYz+3mvuBWOSzRvoriSSkzHCvX+qPllmCoSkmtlNocjfbXFul3+9vX2ZL1q+tonKlISqpTbLq8ze+a0b/HsqiqX7m51Xh5eWGR0fr6lnVkBkJL0+jrv/MY3Sa6t841PfJxHv/AlhOsipESzLCRbppyWrnPhgfsP1E25GVdTyI1EMSo2oZJFuGRRjhuHHkUQEBBw86CogsyQysa2ESIh8PQYQTypNnS6F9u1OT2kMjrePot5FPnOyNu5mDjRKDY39TgX48f5J7NPodJ7BL2q6FyJzWApGjOlRTJ9JBv8cOjulp1X8HZfX0if5y3ZV1F6rU4AIdf0NagCCDlVwGtV79Sm7nbZTI0nVJbm/Z2XU2mN8NMfb1z2yd93eeKln6D7aHNmbY0Hvv4Uybe/nW9+4uM88sUvIVzpr82axgvvevBgDCB9aGhz2SZU9rS5FDcg0OaAGkGBe4sxMqahqrC+6jnohcKCsQl9x8HelbLL3DWzZU5kc8PBdWByxn+V8aiQ16K8mjiN0xQF4CgaBS2K+eA0/2vmw1tX9pmjDZUsxq7nvB9qFu/FVIj18e7Ou5rVWZwVR+L2kYHn6CpmWCNUttsy1HK1+Jel4zMoPju4lq5z/dzZjvdtGwb/8PGP8cgX/7Z2iURxXJ77hYfZHBluue7Q8nLXHQndsrnzRz/m5Qfu57O/+1uMzc2jOg6lWJT7nvkB47OzlGNRXnrn/Vy5846ez3vfkJKRuQKRorl1kRAsHU/eWLC8lISLFuGihasK36iAgICAW4eRcR1VFayv7b02Z9cdHMeLjjnKbGox3kicwGkqNh1FI6/HuBQ/zm2Fq11vPxcZ42sT7wEkEoUfDN3L+dxl3rX2k64ZuDnNfyzFUVQsResr/zZhlxgyN1kNZVo6oTTXarg5R2P+O5DeQkfn94GqCqaPG8xdNxsbuUKBf3zsCf703ntazlNuX3rBd6G6jm7Z3PX887x8/9v57O/+NuOzcwjpUo5EeMv3n2Vsdp5yLMaFB+7n6h3nez7vfUNKRufyhItbf/shpabNfWwodLvfcNEiUrRwAm0+0gQF7i2GEIKhEZ2hkZ2vujmOxLYkuiFYW7XaVhrr8x6jtkTrM5B8EFkKj6Dg4tD6pWYrOn9Uei9065aVktHZfOtOrITYZpVy3KAc73yCYYVU1HJ7m5UUAlft/++5Mp1g/HoOzXRACISU5DNhSgnvsUuJBBceuJ+7n3sezfIKYUvXWZ2Y4PrZM13ve/HEcf7md3+Lqatvoto2CydPUPWZv8mnUz13nF1NJb26yvLMDEvHjzUu//bHDsYxuR/i2QqRotnyesqasM6fTu/ObEpKxmbzhEoWohZzl1orszqd6Pr+UByXaM5EcVwqMT2I9AkIuIkQQjA0qjM0eoPavNJBmzcdxsYl6hHXZr/izFZ0rkfHuxa4DgpfH39X207sa8lTnCjNc6y81PG2GWuTZbXdm0J3bYw+its671v8Hl+Zei95LYqQEleo3JN9g1PFWe/+DKWty04Iz/QzFu/efvvY37wV566H+fVfewXFcVk4cdx3NjafSnXt9AKvbTq1ts7q1CSLJ443Lv/Wxz7a93Pdb+LZCuGi1arNTk2bT92ANl/PESp7Bp8unjavTCeodNNmu9axF2jzQBEUuAE9kVKyNG+R23QaEQU+o5iA95m2raNd4D77e+/C+qILZuvlErCbZjzqX2rClZTjOnZIqzn7+bX/Qixb6VrAZEejjF3PtXxhuwKyIxGEK1FcF0dT+igcFRZOptCrDqrtYoa1ttmUn77rIZZnZjj34k/RLZOr589z5fztyO0DOz44PXZ6kV7VZus6im2hdlgsVhyHYiLZ8/EOk/hmta1tXACq7aKZLnaHSKduxHImoZLVMmuNhJH5AtfPZnxbrEJFi7FZrytASJBrZcpxg9WpeCCkAQG3KNKVLC5Y5Ju1ucPXgRBgWUe7wI04Fd/np0iHuF1q/FxSQ1yJHcMRCsdLC6StPPORMaRfhq3QeC1xqmuBe//aBb42+Z6W4lhzbd6xdgFT0bGFRtQpd90FBog5ZX7p+tdYNTKUtTCj1XUitfbkOqPjOtGY4nXEuZJkSu1oLPbZP/4VAF78ctrz/Pi8DefOdT4A6ZmZOYqKi0UntVcch1JisM0UE9kO2my5aJaLbexcm+Ob1UZxC/XWbU+bZ89lfD9c4aLFaKDNA0lQ4Ab0ZGXJK26l3BrdlB3mQaQE3Tg6H+p6Ju0Hld/buvAFybSbRd02MSMFFDJem289isf7BaRXIZ8OU4l3Xn3vldFWjeoszyTJLBfRTQdHU8hlwkRKFkMrJc9VWVVYm4h1XU30HkxghTW6rS0vnjjesjq7F4RKJd7/158llst7c7UIZK3gb/5bOqrK0swxiqnBLnC7vWbd2ry6EdustAlznVDZphrb9h6q7Rg330ZIiBRMojmTUh/RUQEBATcfy0tecduizR2+W46aNvsxXV7GcC1soba0+SpSckfuMuBF8Tw99s6aSaPguaF7uDf7OhPVVXznZoSoufl3edzKMu9b/C7PDt9HVk8Sc0rcu/Ea12KTPDP6VoSEsFPh4ZXnmelSKIOng6PmRtsCejOxuEos3lqg1c9Vov/xf94ysvxy14dqIVws8v6/+iyRYgHFcUEIpGzXZltVWTh5glIi0f+dHwbd5HeXebgxnwVtAIH0tHl7DJGUjHTS5rwZ5NgeMkGBG9AVKfvPzq0bTak7aKc9DHwzaZupzViOzuVrbb5em/DaZBzbUBGOZKTJ7RgACYlsxStwff5Wbm0OtxfVmM7iqa1jGn9zszFPK/B2jUfn8iyeTN3YnMk+8eCTT5HYyKI2zfjaqsri8WMMLa9gVKsIKbl29gzPvP99h3ik/VFIhkivtpt/uYrA2sXuLVKimZ1mrSV+WwDe6+/fFRDfrAQFbkDALYiU/Wfn1o2mBl2be6Eg+cjc0zw58S7yehyBRJUOjyz9gKRdpKroPD32zpYZXYAL6duYXlj0TQHQXItz+Td7PvZMeYlPzH698fMXpx9j1UjjCtXz2VBiPDnxbj4++/W+jKv65aELn+LHq1f44B9OeBf8QWcjyK7389WvE9/MorpbbxhbVZk/cYyRpSZtPneW7x8BbS6mDLTVcrs2qwq2sQs3ZSlRrc5OXrKjNrej1MbSggL3cBm8M+SAgaJ5ZXg7QkAkolAuu6gqZIY1MsOD+Zb69Id+Z+uHPjJpbUNl4VQazXQQrvSKmVq7SaRo+lryCwnRnMnqVIKR+XyjXpECyjGjMQPbL1rVxqi0f4EKCYn1CuuTg9VCJByHY5cutxlYaY7D6MIi//Xf/A7RQgHTCGGH/P8Wim1z3/e+z7kLF1Bth7nTJ/nhw++llDycnd58Jkw0b2JU7UbeHsDqdGJX7UfRvIlqd4iCEIJqZDA/PwEBAYOF63bX5nBEoVLX5hGNzNDN8d2Ssgt8cvZJNrU4tqKRMTcbLsbXo5MoyLZkdUcoXInN8Mjys/zD2ANIvF1bTdocLy1wsjS3o2NYM1KsGylcpXWR0xEKL6XO8Z7VH+/6+b3lA3ZrR9kflIGJXd8feLo6dfVqS3ELNW1eXOJvfve3e2qzalnc98z3OffTl1Ach9kzp/nRwz9/aDu9+UyEaN5Erzqt2rzL1uBYzkS1/T9QrhDeXG3AkSJ4xQK6IgTousCy2j/44YjCsVODt0Llm0m7S3Yzx1FOGMyfThPLVVEcSTlueIXLDr90Ncv1cvO2ncUIvLzbQUN0WQ1RHM/wqpcY/sIX/pbx2Vk022vHOvHaG0xcm+WL/+rXscLhPT/mniiCpRNJIgWLUMnC0QTF1O7z9pLrZd+5JwmsTfgLczWi1WbHWv+2roBC+hD+JgEBAYeOooCmge0T/xqJKhw7OXjavJek7ELbZX4ztt7l3gLi6eIcY9f+njcSJzAVneOlBSYqqz1nZ7dT0KII2b5QKYXCpr6zgq9+vvLI59+9w6PoH6UW9eP7u1q7ci9tfvTzX2J0bivX/uSrrzFx7Tpf+le/jhU6+PeaVASLJ1JN2qxQTIX2RZtXJ7tpczv9duwF7C+HWuAKId4P/GdABf5vKeX/vu33ovb7DwIl4F9KKXe/NBawY4QQjE3qzF83W2oXIWBs4nDyz/yo57z5ZdLuNeWYfxuyFFCstaQ4ukpuONr5TqQkmjeJFCxsTVBMh9uKaTOsofjlzgqobJ8FGQBcTWNlaorRubkWoXCF6OnODJBeWWkpbsGbrdJMk7MXXuKVd7x9H466D4SgnDAo73AH3g/F8T/JkIDVqa1KCFZmEo3oKSFrXQHxnXcFBAT0Q6DNg09dmxdmrTZtHh0fPH04CI6VFnyzZjXpcrZwDYC4U+at2Vc73oeD4Ep8huuRSaJOmTtyl0naxZbrjFSzXmvyNlTXZrK83PM46+crv/+HE5451D5jGzprE+MMLyy2aLOjKFzrZhhZY2hxiZHtufZSolernH7pZ7z2c2/dh6Pugz3UZuF21man00aHEKxOJ1pNpgSUAm0eCA6twBVCqMB/AR4HZoHnhRBfllL+rOlqHwDO1f57J/B/1f4fcIDEEyrHThqsrdiYVUk4ojA8qhEK726lbK9oaTv2yaPdL2TN6Gl4sdjShlxMhahG+/hIuZKJa5uN1hoJJDcqrE7GKTfNbEhFYGsKmrUl2bJ2eT4zmDt3z7z/CT7yZ3+OsJ2tPD4peePuu3reNrO8iuuzSqrbNqMLC7yy94d74JQSBon1SttKsVRF126BalRn7mwmiAkK2HcCbT46JJIa6knB2rKNZda0eUwjFDpcbT4swq7Jz6/8kO+Mvh2JQAqBKl3O5y4zUVnteXtbqPzt1C+QNRLYio4iHV5K3cZjS89worTQuJ7uWkTtEnm9aWdPuhiuzV25S773/dCFT211lB3g+Uqd733g/Xz4z/4C4TRrs8ulu+/sedvMyoqv1tS1+TUOqcDdQ8oxAy1baVsekarA1jt/nioxH22O3JoLTIPGYe7g3g9clFJeBhBC/Ffgo0CziH4U+HPpWb09K4RICyEmpZQL7XcXsJ9EoiozJw4v7LpuDAXccNvxXlBKhalGdWK5WkxQwuh7RiOerTSKW/AKZCFhZLHI9YTREJLRuTyq3b4evToZ23Ubzn4Ty+c94az9XBfS9/z91/jcb/9m1xiifCbl2ypmayrZkfYMwqNIbihCLGeC4zYWN6To3J7cjKsqDRfvgIB9JNDmI0Q0qhI9eXjaPGjcVniTycoKl+LHcITKieI8I2a2r9v+LHmarJFsxAG5QsUV8A9jD/DPr34Jtda69fWJd1HUoi3f2QL4haVnCbuePfJDFz7Fv31mwYvwgV2bQ+0VsVwOKUSLNiPhPV/5Kp/7rd/sqj/5jL9fia1pN402b45EiBa8sbIWbe7QntxMoM2DyWEWuNPA9aafZ2lfAfa7zjQQiOgNUCm7FAsOiiJIpNSBzaytZ7wBfHoAitrteG3I7UHqvYjlzQ4xMVtW9KrltGSlNhPfNKnEB3O+47YXXkSzW+eDBaBZFiPzC6zMTHe87erkJLmhDOmV1YYLs8QLnX/93nu7Pq5RtojmTaQQFFOhXc1OHwSupjB/KkWiFlJv6yr5TBgrMLAIGBwCbT4kGtqsChLJwdXmQSdhl3hL9rUd3+5i/ERL1m0dKQRroQxj1XVyWozF8EibwRQCvv74w8Q+rHpF7R+U6WZkedDc/sKL6NsGtgVgVKqMLC6yOjnZ8bbL09Pk0ylSa+ut2qyqvHHv3Z0fVEqMiu1psyIoJgdbmxdOpYk3a/NQeCDTKgL64zBfOb9v7u2n8/1cx7uiEL8J/CbAuL7zouNWQErJ0vxWpq0QXsbt1DGDeOJwv3TqGW/QlEm7g4y3o4TstBoovfgZ8Aym6GAwpR2QwVQ0VyW1Vka1XaoRjY3RKHaPL3vdNDsaduhWt1ReQAi+/k9/iQeefIrjb1xESMn6+BjPvP8JKvGY/22kJLNUJL5ZbWTWJtfLbIxFKWQG83tAqgq54Si54cM+koAAXwJtPmCklCzOWeRzTdq8aDF93GjLQw3YP3Tp49iFZ16lSk93C1oUVbptTs0ShcJllYt+0YN7iZTEcibJtTKq41KJaGRHY9g9Yut00z94VwqBZvahzb/8SR548imOXbyEkJK1iXGeef/7qEY7eI1IydBikViuSZvXyqyPxygOqDmiG2jzTcVhFrizwLGmn2eA+V1cBwAp5Z8AfwJwPpLeZczzzU2x4DaKW9iqneZnTc7eHkZRDna1uJ7vBmxlvN0C5DMhQuXW3VlvNVRpZKtaIdXXkVhCe9j4PpBYK7fkv0YKFuHSJgsn011XYK/ecZ6xufm2Yla4LsvTnXdv65jhMN/56EcQjoPiujh69+caKtvEt4WzCwmZ5RKlxO4dFQ8MKYlvVIjnqkghKKRCnvtiMFsbcHgE2nzAFPNuo7iFJm2+bnLmELT5VuXOzUssh4awlSbdkS5Ru8yQuclDFz7F965cofL7env+Kgdj/phcK5Na28p/jRYsIqVsT22+cv52RhYW0K1tu7hSsjLVefe2TjUS4dsf+8X+tblke0kS27R5aKlIOWHgqgOuza4knm3S5nSYYtIItPkIcZgF7vPAOSHEKWAO+GXgV7Zd58vAv67NAL0T2AxmfHZPLts5FL5UdA9sF7dhDrUH+W4HiXAlqu1iawrcwAlHOW5QSIeIZ6u1O/ZWUZePbWWruqpCPhMmsVFpCITXrivIDW1b/ZS1gZE9OgkSrmwpbmuHCC6kVkusTXWOE7h85x2c/ekFhpZX0C0LVwhcVeXZJx7DNvoXf6mqOGrv92M0bzZWh7cTKZgDu1Ks2C6q5TC0XMKo2I2/tVGxiRQtL2c3IOBwCLT5gNnM2h21uVxyg13cHlhCpayGidllVPxzxvvhdPE68/lRXkucRuAiJESGQrwyNMP/cu/vNM5Z0ukiiWyrNktFkB/a1qGwD9rcXNxCkzavlb150Q5cuvsuzr70MpmV1RZtfuZ9j/csVpvpV5tj+WoXbbYGNkanoc1LJYxqszYXCBcM1gJtPjIcWoErpbSFEP8aeBIviuAzUsqXhRC/Vfv9HwF/jxdDcBEviuDXD+t4bwYOeum8nu8G+5vxtu9ISXq5RCJbaVyUG46wORzZ3WqeEGyMx8lnIoTKFq6qeNFD2+4rOxrFMlSS62VUR1KO6myORnF0T1yE4zK0VPRMiwAzrLI2Eb/heU7N8m+BFng7pt1wVZUn/9k/5fjrb3D8jYtUolHeuO+efTOi6PqeHsCVVuFKhufzRItWzcWytddTkV5hbpRtzEgw+xNw8ATaHHBUcBE8O3wfP0ueqX2PSt628Qpvyb6y42xb8L6L//1/tPk3yzpX/i6Cq3XQ5rEotqGQ3Kh4WfcxnexIFKfWMaQ4LkOLRaL5ujZrrE3GbnieUzOdjqNLoVL3NmNX0/jaP/unnHj9DY5dvEQ5GuWN++5lc2R/+nE7ZRJ7C/r78pA3hHAlI/N5wkXv7+inzdGCSa5iB54ZR4RDfZWklH+PJ5TNl/1R078l8LsHfVw3K6m0SjHvv4sbje1du0g94+2Rm6TtOLVWblmtBa9NyFHFDc152oba3XBBePm4fruQesVibLbQ4rJsVBwmr26yPB2nktj96qijKR1PDrrZ5deRisKb52/nzfO37/oY+qWUCpHIVnxXikvxwbPqH1osEClabeLZjJAQKltBgRtwaATafLAk0xrFgumrzZHogLdyHiI/zNzFK8kzOE3GUD/O3EnYqXBH/kpf9/GWD9i8+u8/CWzLpe02Sis87ffTf71sMTaXR7VlkzbbTF7ZZHkmfkMGkY6mIDqMLvVj3iRVlat3nOfqHed3fQz9UkwZxDd9tFniLRoMGMMLBcJFf2PPZsIlKyhwjwjBq3QLEYsrJFIq+SaTKYCpGeOGZ3w+/aHfIbG+we0vvEjs3c+xcOIE2l3DO2pLHUikJLleafvSUySk1ioHb2RUN1XKVr14oaZf1f89Oldg8aS66y9hV1UoJgyi29yeXQGbwx0MJW4A1XJIrpUJl21sTSE3HOl7ztgMa2wOR0ittbpsr07GkYc84yNcSSRvekYgUR1bV4l1aamuIwWDP58UEBCwZ8QTCvGkSiG399oMYFZdsus2liWJxhVSae3Iz/VK4KX0bW2ux7ai8ZPMnT0L3MaoFOxNLq2UXkdVN22eLbBwSu1p1tgJV1MoxQ0ihVZtlgKvo2yPaWhzycY2FHJDO9DmiE5uKEJyfZs2TyUGQpuj+a3cWltTiBZ6azPQ2KUPGHyCAvcWQgjB5LRBZujGYoLqmbTNebRTl6/wyJe+jHBdVNdl+spV7nr+h/y3f/6rWOHBnIPsF+H6f+upzu5nfXZLuGR5pkpdriPwdp1vZI5zbSKOFJ4DInjzRetjUap7vPKqWg6TVzZRXG+1W686hEsWaxMxSqn+3je5kSjFZIhI0QIBpQEwsDDKNuPXcy2tZOWY7p289rqxEJQSxr4eX0BAwOAghGBqxqBcdintcYRfIe8wf31rd7hYcNlYczhxOoSqHt0i1xYqtvDftSyrrdrx4GfuRbzj8ZZzlr0mXLSI9anN3XwserE2GffcifPVxuzv+nhsz80nNdNh4mqTNpsO4aLF2mScUrK/XejN0SjFVIhw0UIKBsJcyihbjF/Pb2nzCpTjvbXZy8UVlOOBNh8VggL3FiQcUQhHdvYl0y2TVrgu7/77r6I1ZazploXI57nr+R/ywnuO8PytENi6gm61F7NmD1v+/SC22dm4oY5XKHaflUVKwiVPkAGKyRCV5lkjRbA+GWdjPIbiSBxN7MtMa3q13BDQ+rF7ToslT0T7fEzHUCkMSr6elIzO5VC2LYzUC/Dtg8OS1otXJ2PIbbsrkYJJeqWEZjrYhsrGaJRKILQBATcVkYhCZIfa3A0pJQtzra3PUoJtSTbWbEbGjm6HlSYdYnaZgt4eITdczRJ++uP82eteofvpz6fh8/tX3AJtbv5+CMCo9oj5267NqZDnzlzTQqkI1qbirLv7q82p1VIHbS56C7B9PqY9YNo8Nptv1+aCV4D31uZ4uzbna9psOViGSjbQ5oEhKHAD2qhn0jbyaKFrJm1yfQPNai+oNMfh5GuvH+0CF9gYjzEyl291TBSwMdYhm3Wf6SUrEnqaWWSWa23OtVXLaN6kmAyxvs2FUSoCZx9b2cJFy/f5CCnRLHdgQ+G7YVQcFKf9TEeRYBoKmuU2/u51AYWtnxPZKuWmGepIrsrIQmHLzbHqMDqXZ3UqQTnY6Q0ICOhAtSp953qlhHzOOdIFrgAeWv0x/zD+YEubsivghfOnee4PD/q59e5vlfReGB9aKrYsZEfzJsVUiPWJA9bmUgdtrqVJ1M0ujxJGxfadYVYkVEMqwnRazvPatHmzQqVJc6O5KsNN2hyqafPKdCIocgeAoMANALYyaX9/F8ZQtqH7fmkAWMbR/5CX4wbLx5KkV70dNCukkR2JYEYO/uSgmAy1zcZup9c8jl61iWdbV5sVCbFclUI6fKDmRo4m0Hw2mwXgHrX2OSm9FW/X9d2pBW+2dnkiTmq1RLhkt51ACGi4ONbJrJR8Z8Azy8WgwA0ICOiIotCx7lKO+Cjhg5+5l/CpsyRehb/8Lxqa5WCGNDZHo5iHYAJUTIaJFLqbFEnhJTB0Qq/YXpvztuzY2GaVfDp8oOZGrqqA3b7bLPDiCo8UdW12tu/JbuGqguWZJKm1HWjzcidtLrEQFLiHTlDg3sK0mCzcQCZtMZkkOzLM0NIySlOha+k6r7ztrTd4lINBNaqzdDx12IdBJaZTSoSI1jLmpPAE0AUUvNXhjfFYVyGMFCzfNmdRi6g5yAI3NxRpWQEFbwW+EtMPfVanL6RnVhEuWESKJqrPzm0dV3jtZtWozvKxJMdeX/d9HWTz067tZPvR6fKAgIAAAMNQMAxBtbotVkZAZvhonv41zls+33ThiUM5lBbKcZ1SzZyxRZtFrXsnrLI+3j0qqO6wvx0hvd8dZIG7OeyvzeW4fugmUX3hSqIFk0jBItyXNoepxnSWo0mOv77uuzAkm9uypbeT7Ydu9mhDDzgQjuY3XMCOqWfS7lce7bc+9os88V//hkixhBQCxXG4dNcdXL7rzn15vFsW4c3f5MthIgUTV/UMiXbSLuQqoiG+zXjuvQe7MltKhtBMx3NBri2sVqM6q10C6w8bzXSIb1QwKjZG1fbajbcZVNRlr/53lgKqEY1CPdxeCIrJELFcte0EonGd2vUcVaD5iHPg5hgQENCL6eMG16+aOI70ztklpDIqieTgt5ju93nLniIEa5Nx8hmbSMHytDkZ2tH3tBR01OaDzo4tJQx0M0KySZsrUZ21yd0bZO03u9bmqE4xWdtxFaJjikQh3arNrip8C2c70OaBIChwb2LqebSw/5m0xWSSL/4Pv8HY7ByRYpHVyUmKqeS+PuatjBnRdr3TWkoYZJaLHX930ORGouSHIuhVB0cTAzXbo9guycWtsSkAACAASURBVPUykYKFoymUYzrp1ZLvDG3L7fCENJ8JeycGMb3VxAtvtls3HYzKVo92NaKRHW2d7d4cibS1QrkCsiMHHFEVEBBw5NANhVPnQpRLLrYtiUQUdGNwT8AP8rxlzxECM6LvenypmAyRXil1/N2BIgSbI1FymQi6OeDarCuUozvT5lw6jAAqcb3FxAtgfTyGZrnbtFknO9Iak5gdjrSNELnC0+yAwycocG8y9jzbbScIwfKxmQN+0COAlBgVG9V2McPaoYuEqymsTCcYncvXvtQlSM8h8LCOTSriQFuj+0GxXSavZFEc6UU/mE6b8UbXWAFF1Apb/0UDqQiWTqTQKza66Tkw+rWgFdJekVx3nHZVQXY4QjF1wCc8AQEBRxIhBNHY4BQnfjTOXQ7yvKVFm3Uc/XALf1dTWJ2KMzJf2BIX6WXHuoe0KyjVwdTmqZo2C/C0udi/NqNAJWF0jFaSqtKqzSHVt7W8kPGK5FSzNo9EKKaPdjTmzcJgvWsDdkQ92w3Y13y3gF0iJeGCydBSEdWWoHgtMflUiI3x2L5Y+/dLJW4we26oYZpQielt9vd+aFUHo2pj60rDyCOWM4lnKwgpKSZCFDLhvu5r0Emul7eK2xo7eVaKK9FMl6hTpRwzkB3av62w1n22SggKQxFPTN3ajO4hvncCAgICdstAnLfUtHl4seg53tfMuPLpENmxw9XmciLE7DljF9psY1QdbF3FDHuLGS3anAyRT4fhJtLmvgvabQjXO5dRbZdy3Oj49+1Hm/NDEfKBNg8kQYF7xDjobLeA3aFaDmPXc+imN/EhoDH8Ed+sYkb0Q9+Bk4ro34VXSkbm8kSKFlIIhJTejmNIbZlV0aslYvkqiydSR/6LPly02O2auYv3mmdWaq3gtR3y8o20mQmBZtlECiZS8WZ4D2tVPyAgIGAnfPaPfwU4/PMW1XQYv55rmPQ1a3Mi62lz6aDbgbexU20encsT3qbNtqESKbRqczRXZekm0OZIwT/CqB/q2jy0UmwYSa1OJyjfiOuxEOiWTTjQ5oEiKHAHnLZM2oNuOw7YFWOzeXTT9Z8BkZDYKB96gduGlMSyFRIbtRXfVJh8JoJUBcm1MpFiLQKh5pRtVB2MqtPyHBUJetUzeiimj/ZOriv853i2X7bdYsJWQXO864gmk8WRhQJzUX13widlSz6iFJBeKd140RwQEBCwx7SdtwB8+ZAOphkpGZv1ituO2rxeOfQCtw0piW+UG9n1xVSI/FAEqQhSq2VvMbYPbTaqDvFshWLqiGtzBwndtTbP5Zk7m9ldcoOUDC0WieW2afONFs0BN0xQ4A4YD37mXn5y6izArjJpAw4freqgmU7XFcaBi3iRkokrWYymolxfLRPbrLJwKk1iW24udIx6RZEwtFwis1Iinw6THYseqRVjxXZJbFQIVdqt/uvP1xXUAgHBjKhUogZmWKUcN0isV0ivlHxf/2jepJDZ+XxOuGS15CPWXTZHFgrMdmmxCggICDgIms2hPjig5y666XQsbuto1oBFvEjJ5OUsetNxa6tlYjlPm+PZys60ealEZrlEPhMmO3oEtXm9glFxOhaz/tqsUY7rJNfKpFf9uweiedPzu9gh4aLVkobQ0Oa5PLPnhgJtPkSCAndA8M12O2ykJLO8gmZZrE2M42rB26UfFNftrDD16zgSxXEHJus1tVJqKW7Bewqa5RLLmwjZ5cn4IPC+6BPZClIRbI5Ge95mEEislUivltuiBeoIPAFdOp5EtV2skIZttJq3KK70v630frcb6ju3fgcULlr9t7MFBAQceaSUVCsSV0rCYQXlEE+iD8UcapcojvQKui56pjgS4bgDk/WaXi62FLfgjQxrptsWZdMPDW3eqOAqgtzI0dDm5GqJ9FoZempzCtV2MEMazjZt7nYeI3apzfHN9sV/7w4F4ZIV7OIeIkHFcggchWy35No6j37+C41cW4Hke+97gjfvOH/YhzbwmF2C3OvIWmEyKK1QyWylo6V+uGhSjunEcqbvdTrZ8YO3YpzcKHu2+Ye0UqxXbVTLxQprXTMJQyXLcyruoXNC4hlsdXg+5YRBcr3sm2VYju8uPiIgICAAoFpxmbtmYjeZ7IxP6SRT+386dxTOXbphhrWuxS3gLRqW7IFZNExkq1202aIU071FaJ/r9NTm9cqhFrh1bTbDWtfRnVDJIrXWrqnb8bRZBeH/WSjHDZLrFd/72etCdHflcsBeEhS4B0TdHOrFL6cHa5fWB+G6vO+zf0O4UGwx2Xn3V58kOzrK5sjwoR3bkUARrI/HGFosdtwJBHA7uOoeBqJDx7TECy0vZCLenI8rUWTNk0PA2mSM9EoZ1XY773q6dFfafUJxXMau59GrNtTMNwqpEOsdHKzr8029sEJq12LdDGsUkwaxza2TDgnkkyHfqIF+KKZCRPNm+/HVMnYDAgJufqSUXL9axal10da/DhbnLMJhBSO097uObcaWRxhZ1+alLtosBO6gtJVK2VGTJGDrCsVUiEjJQjRrswJrE3HSK6Wu2qy40iv4D3jx2dPmHHrVaWhzPh1io4ODtecE3ft+veK2hzYnjJbFeomXbLG9E6tfCqlQi5lXHSGll68bcGgEBe4+cqiZtDfAxLXraGa7g6ziONz2wos8/9gvHMpxHSWKqTCWoZFaLRIp2u1GRYoYqC8/K6RiVP1njwqZMI6uMH86TTxbJVS2sAy1drlKKRFCNx1G5goYZvt92LpyKNEEw/MFjErtb19btY9tVjFDKoVMexC7cLvPZtX1a3081vOxHVUBsTWPI4FoyWJzl61vlajnut1sMgVePmIw4xMQcGtQKri+G5BSQnbDZmxib3ah3vIB+6Y1tiymw1ghjfRKkXDJR5sFVKMDcmosBJahYJj+K9DFVAhHV5lr1uaQRiEdqmmz4WnzbB7Dx/fD1pVD6awamS9gVJwWbY5nq5ghzTdDttPYT52+tVkIb6d4uzYXLTZduSstrcR0islQi8kUeM7MgTYfLgPyKT76PHThU8DNkUcbKvs/B0VKIsXiAR/N0cWMaKwcS5FYL5NeKTWWUCWC5ZlkV2FRbE+MDspqfn0sxthsrrHSWxeM7GgUR/dWNqWqkB+OkGdbcSgEVkhjfSLG2PVcy2qxK/AyfzshJcnVMolNb4W2HDfYGI3e8PMWjuutam+73GuZrvgWuKVkaMspuvkQa/+3NYWVmUT3XDy81y650Wr8oQDYLvFslfxw+2P3RAjWJ+Lk02EvqkmBYiKIIggIuJVwHNmx9dG2d3ef9XMXuDnOX/rBjGgsH0+RWCuTXi01RE8qgqVjg6XNG+MxRmfzbdq8MbYDbZ6M+2pz14LQlaTWysRr2lyKG2T3QJsVxyXcRZv9CtxSIrTlFN1EQ5t1heXpBHaf2ix8tblCfmiX2jwZJ5/xtNlVBKWEEWjzABAUuDdAS9vxTSQMyzPTKE77Tpyl6/z/7N17lKR5Xef5z/eJe2bkrSpvdevqGwrItiULSCPONIoO1ahgjzjKUdRhbXfRRY7MjtCc1dXRPTrDcVdXZ2x27YMX1GZEpB1QhNl2GB1xYLn3NCA0XVVZ96y8RWbcn+e3fzyRWREZT0RGXp/IyPfrnDpdmRmZ8cvo7vzk93l+v+937p67Y1jR4ZSs+BszS6+eHVO66ivwLNxS2iFAU5W6Jq+sKtW4E1pNJzR/ckT1zDa2zzinTKmuoUJVTuFV3q2KsspwStfvGNX4fEmpcl31lKfF6SFVh3q/I1AZSun6HWMamy8qXamrlk5oeXJIlS53qqfmCsoWbwfX8HJF2bWqrtw1IbeLLdxe4DruijY/+lfE4kha+aWkMqW6PBeGp7NwC9LK8dzGLxNbSZfrkY1MPCfl1qo7K3Abthw8D2Bg5Ya8yMN9ZlI+v71fqDfm0g7Q7y69SlXqyq2GxchGNicau6p6zeZMI5u3s7W1OZtNWhvdOpvLw+kwm2+WlKrUVU97WpwaVnUbO8DCbG7ke4/ZPD1XUKZ0O5vzyxXl1mq6cvf4ru5Mmt85m70O2bw2mlZ+Oan0LrM5U6orMCmx6Wk8F55n3lGB20A29x/+bfRofa7b21/7hrCglQZu68664siInn7RC/XcT31GqVpNklRPJrUyMaFnn/v1Ma/u4Hl+IAtc2KCox+084zfWGvNkb29ZuXUir3KXRgYWOM1cWGnZjpOu+Jq9uKzL90z0HCrN81KlsJPx0vGcCls0k6jmUrpxZnfbpsO71qM9PTZVrrcUt1IYeom609SlZd06NdJzcG3mJz0FCW/javs6py7NJMx048yocqtVDRWqCjzT6nh226EVJL3IRiZhKFssZ54AHH6ptKexiYSWF/2NHzFmUjpjGhnt/LOyb+fS7tKOsvn6mkaWWrN5/kRe5eEu2ewH7dlc9jV7YVlz90z0dgRn07xUKexkvDQ5tOVFz2oupRt37Dabe8/3VLneUtxK69kchNl8chfZnPIUeNZWzDpJxU5NGC28sz5UqCq3WlXgeVod3/riQNtzJy3yLK9r/CGbBwsFbhfrM2lb5tEOQCj04lP/6Ft149Qpff2nP6N0paqvPe/r9Q/3/XdHalSQ5wc6fmVVuWJNTlLg2ZZFqiSlSzWNNG1RXf+BevzqqkrDqY5nMIdWKjLXetYkbOnvNFSoam1s647L6VLrvNT15x+/VVKxcV5nNzw/UKLqywvCJllbNVzqutYOZ35NUrbs68TXlnX1rrGdrdlMt060bu0KLNyCtjzZ5ZcJM5VGMiqN7Ly7dTWTUD3lKVVtP9ObLdZ08pklXT8z2jbCAAC2Mj2b0tBwQksLdQWBNDrmaWwiKdtUZK3Ppf3dL2f1yBOHuznUZp4faPLKqrLr2ZzwdGt2eMtszhRrGllqz+bJq6ua65LN66Py2rI5cBparfY0DSFTqrfMS11//vH5ooqj6b7K5kw5er+7ScqW9iKb85q63J7NXTs6m6k4mtnV5IlqNik/5ckisjlXrOnE15Z048zorv9doD8cnWqlRy/7/Ftvn0Pp827H+8pMc/feo7l774l7JbGZmisoUwqbUJjC7TNTlwu6dnas65XD4eWIbrcNudWaih0K1WQtiPw8C8Irp72I7LTb9NyrEzv8we2cjl1fU36p0vJuP2G6eWY0HL+wTfVU5y11pnCb8ditkhZm85HryZTqypTq8pOeiiPptjvc5eG0rt45ptHFspIVX+XhlFbHs93PxjinhO/CwN3pHMTGneCpywWlGo00Nv44yWqBpucKunr3YP3SCWD/mYV3a6Pu2N7/2H23R/gM6A4zSZq+tLLRpMgUnq2culzQtTvHunaq7zZPPNdlbF+y6keOjzMX5nYvumbzWk2r43ufzTfOjO5o22w9lWg98NtkPZtHb5W1OBtxhreXbM6nde3OMY0slJWs+SoPpbQ6kVXQLXP3KJuvnxnV1FxBqUp7NqeqjWy+i2weBEe+wL3/sfv0ltoLbm87PoLnUdAuWfFvd+BtYo3ZcbdORhRdG7oME+/yWZVcUq6pu9/GV7NG+/seuC5XbN2mD6VLdU1cX1OmXFeQMK2MZ7XSYV7t2Hwp/OVg0/uTvtP0xRVdvrf3LdTrKrmk6qmEUlW/4+D27Fot4htxG2d317eZTVw3Xb+jPczrmWR0gRwhU6zp+NVVJRsXE8q5lOZP5nfULMJPJXTtznFNX1hWrtR6NdwkJWt+eBZqh2ODAOD+x+6Tvfg7jtRF+VS5vlGcNDMXbvnt9ef9dlRyKQVWbm9yZFKlxwIy6Fa7bcrcdKmmievF29k8kdXK8e1lc8J3mtlhNpeHwpnxUXc6pUY2F6uSNhW4zmn60kp4Y8BJzmtk89nRtqxbb37Vi/VsTtTD9ZSHUpo/sYtsvmtcM88uK1uOyOaqr2TV3/HYIPSPI/fb1bnzdb39tW+QpEMxkxbxSNb92+clm6wXJ90URzPKd7hSXOp0xkRhu/laOiz41oM0sHDLa68jhdZGMxpdiB6I3jy4PlnxNXNxeeN5Er7T2EJJyXoQGToji+3hvs7klCtUO96Z7sjConTySiFyXIMUnteJWkvz2V1z4XzIqcsFXbl7fEfbshI1X9OXVlq+x2yxpplLK7p659iOt3p5UTM9JMnazyABwFbWm0Nt/P7yvqN1UT5RDyKb+K0XJ90Um8a5tHBSqcs88VI+pXo60XInN7Bwy2uvI4WKoxmNLkTPc20+e5qq1DVzcaU1m281snlz8e6cRhdL0XeXFR5vyvW4hbr1k03X7hjT5OWCsqUO2ZxsLwBHFsobTRqlcPeZk9Pk5YKu3j2xvTU0JKsR2bxW0/SlFV3bRTZbx2wOt3tLFLiH3cAXuOfO1zX0r3+2tf39ETlHi52rZpKRxUlg2rLYrOTCOXT5pcZcNEkyaWF2uPsWHDNdPzum0fmi8itVSbe7BPb6Q7yeSWhxekgTN4ot758/kW957rFb7UWw56T8SqV9FIBz4UD4TgIp4fe2TavtU5OebtwxpqmLy8oW6y2zlwOTliO6GuY3nTGWbjfASNaCHV15HVls/8Vj/RemdLmuam5nDT6KI2mlKhG/gDjX85V/AEfToDaH2o1aJhlZnPSSzeWhZOs8cUky6dbscPdtr2a6djacEDC8Ek4nWB3PaOVY79lcyyS1ODWkYzeLLXu85k+OtDz3aIdsHl5uZPOmddoW0bvTC6lB0tONs2OavrAcFq3NHzNp5Xj7OJ9O2ZysheeDd9J3It8hm1NVX+mKv6PjUVIjm6vRFweq7KwaCAP5bzH/DTN62SebztKy7RjbFCQ9rYxnNLJ0+we2U9gIoTDR/oO9hZkWZ/JaHcuG4wA801qPTSScZ1qeHtby9BYDy7tYncipOJJRbrUaNk3Kp9pCMV2JvirrzJSs+ao2F7hmqmYSynRoCqXGFur8YlmeH6g8nApDZxtXVudPjWw0DVk/+7M4PdTaNMQ5jSyUleq0DkkK3MaooXoqsTHwfiudtklLYThXMy6cqxs4lYfbX89OCuM55ZcrUi1oGW+wMDPcW+dNAEfK+lzaozKTdrv8lKfVRpG6OZtXe8jmhdm8VsezyjU65ffa4Ml5pqXpYS3tJpuP5VQazSjbyOZivr2xVdTRqHDtUrIaqJprzeZaOqF0lzvXtXQjmwOn8lBK1dz2fu2/eXpEU+sNvRoLW5waau067ZxGFkobI5Qil7/X2WzhziulE8oVa5ILv79ez+cWJrJhNtdbs/kW2TwwBrLA/dLlgHDAri1ND6uWSWp0oSwvCFQaTmt5MtfzuY9aNqnlmO7SBUkvcmD6umom0eEckwsbTGyyODPcNihekgKFZ5CmLxUany+5WyUV8+nwnHKPRa5LeLp5ZlRePVCiHqiWTrSFzPGrq2Gjjg5fI/BMU1dWlaz5G4E1ulDSzdOj4ezhLspDqchB8uHipDNfWdTG2WoXFqjdXt/b35fp6p3jyi+VlVutyk96Kkzktv1LBoDB1dIcit9dtrQwM6xqJqGRxUqYzfm0lifb7252Us0md3znb7f8LbK5lkkqVY3IOSfV0+3f38Jsl2zOJTU9tyJJG/0qiiNp3TqxvWy+sUU2T15ZVW61czb7CdPUlYKSjQu9gcJsvnF6VJUtsznZNk4wXFh49/rMVxbkZDK5bWazF2bzclM2H8vF9t8F9h7/JoFOzLQ2nu3ph+Vhs3I819bVMWiEX1QBXxlKbWzRypbqYdimPBUmspq4vtY2+mBotapS4fbZH/N9nX7maxouFHTzxAndOjHb9hxSWJhHPX+y6muoUG1v8tH4Iy88x5Rfuf2Y9c6Ix68UdPneia6BvjrWOLtcvz0KIrBwZu7x66vyNm0DO3Z9TdVcsqcmUc4zFY7ldjVEHsDgOHe+ri/+y++/PYKQXiDbY6bViZxWJwbvZ+ry8VxYLG7K5rXRTGQB3y2bj0Vlc6Gq4khtoyeH5/s69cwzGiqs6ubJk1qYnYlcV7dszq22Z7MUFrLyTOXhdMuIJE+SnDR5taDL92yRzePZ8Oyy35rNxXxax6+tNr7m7Sc/dn1NlaFUT0eVXIJsHmSxFLhmdkzS45LulPSspO93zi1GPO5ZSQVJvqS6c+5FB7dKYHDVMkndODOqietrSld8OU8qjGe1NNV5Dl0tk9D8qZGWMMoUa7KIhh/rZ4aKoxnll5Z1/g//SMlqVV4QyJnp+unTevKh1ypI9HYmJ1WpR44tMIVbsK6fHdXMhZXIkPUCp1TV71qMrl/NHZsvbmwrL0xk5Scs3Oq9ia2fiZrmGiEGB9m8f9bn0m4UtQM8xgc7V8uG2Xzs+ppSu8jm7FotMjPDbC6rNJLWyOKiXvWHjytZq8kLfDmZrp29Q0++9nvkeszmdIeZuevrun7HqE48uxydzb7bsm+GS3i6dte4xm4WlVttzeahtWr77wSN7295audbyTEY4vrt7G2S/qNz7lfM7G2Nt3+2w2Nf4ZybP7ilAQfPgrATcbIeqJJLqpLb3hnWnagMpXTtrvGwOO3yXBY4jd9Y2+gMXckmtTA73PN8vX/0xJ8ru1Zsado1e2lOz/vkp/TUN7946y/gnCxwbUEmhe8qNc7Eum2MYYgSJD0tzua12HRzeXipHPnY9VmA29aYEej5QWPoPJ0a0VfI5j2UffIhCtpDzgKnoUJViQPO5qs9ZvPEjbWNplmVXFILM+vZvPW4wn/8gT9Xdm2tpYHUiQsX9dxPfVpPv7iHa1br2Rz1IYWTIVzC6zqmaPP4wih+0mub7pBfKnf8FjfvuOpJSzanIic44HCJq8B9jaQHGn//XUl/rc4hCgy0ZKWu2YsrMufCtvomVXNJXT89ejDNDrYI68nLhZYzMJlyXbMXlnXl7vFwdm/E5wQmrY1llF1b0+jisoJEUl799kzbZL2ur/vc57YscLOrVU1eWZXJbXS9bF6tM200FimMZ5XatCXLSaqnEzueadfp7O76FqntSNR8zVxcud1x2kmF8UzYtGSff2ECekQ279D9j90nSbfP0koUtYdcqlLXzIVGNjfOsFZy4R3WA/mZvcVzTM0VlCk1ZXOprtmLy7py17jKuZSibuEGFh7JGSoUNLxcUJBMRWTz57cscDey2XXO5sJGNmc0caPYls21dGLHF3lLwylFDR5yjaNF25Go+pq5tNIYQRXeBV4Zz2ppeohsPsTiKnBnnHNXJck5d9XMpjs8zkn6KzNzkh51zr3rwFYIHJCpy6vyms6XmJPSpbpGF0taOd55W9JBSFb9tgYPJkkuHK2zND2s+VMjmtrUyKKUT6uaSWh6bk0f/47XSZJGFuf1vE//Z+WKq5LWZ811lqj5mrpcaAvF5rgujGc3ite1sYyyxZqGCtWNhQae6eapkR1//34qoeXjuY2xSqbGOIrh1JaNqzabmgubbDTH5chSRdVcavtzCoH9QTZvw/2P3ae31F5weyYtBkdjtroXtGZzplTXyGI59nObyUq9pbiVGuVscDubb57Ka2quqQFko89GLZXQ9OWq/r6RzaMLN/XcT/+NcqW9y+aViexG8bo6nlWmVN+Uzd6us3nlWC7sndGUzaV8WuUeZxOvm77clM2Nb2JkqaxqLkk2H2L7VuCa2UclRXWSecc2vsy3OOeuNEL2I2b2Refcxzo838OSHpakzOjUttcLxCFR85WstXcz9lw4Uy7uAnd0vn0mnxSGyfrZm/JwSpfvndDQSnVjTFAtndCpZ5bk+U7OC0NuZWJKn375g3rpR/9EgZmeed5zuz738HIl8sxts5Glssr5VDiywEy3To5oueorU6zJT3phEbrLK7Ark0OqDKUaYymc1kYyKuW393WTVT9y3IHXuFBAiOKgxJnNM6nD3cyF5lBHR7IWKLHpgqTUyOalSuwFbtS8XCls4LQ+Sq88nNbleybCBo1+oPJwOszmry7KC7SRzcvHpvXpl5/XSz/6PgXe1tmcX6pEzqZtWd9iWeV8WpWh1O1srvjKlGryU144s3iX2bw8NaTy8O6zOUk2D6R9K3Cdc6/s9DEzu25mJxpXiE9IutHha1xp/POGmb1f0kskRYZo4wryuyRp5MRzdjbZGugnMf9XnCrXNbxSiZ6XK7W00w8SXssMwuGlsqzpyrckyfPkJ5K6dupuDRUX9YWXvqTr8yfqgbY6BeM5afRWuWUm3262JHdSGUqFQb1DFrjIhh9S2GgDOChxZvNzc+OH7j/2trm0bDtGzNKlmoZXosfyBNqUzcnWbM4vlcNtxc2f5HnykyldP3WnMpWVLY8OJerthf9m5sIi/GZTbtYzCdUz/ZXNXrds3kmfDfSNuLYoPyHpRyT9SuOfH9j8ADMbluQ55wqNv3+npF880FUC+8xPevKTnmzTleL1czJxyi91Lm6bz9dESdb8yKvLfjKlL587p0tfd7prB+VE1VeQ8BRIWxa5iXrn4fL9opZJyHU4D1Uc2d55IWAfkc2SHn/09eG2Y4m5tEdUPRVms1dr3a4b9peI92d2frlzNqupL0WUZNWP7GjsJ5P60gv/e118zqmuHZSTVV9+0rbMZlN4F7zfVbtk8xrZfKjFVeD+iqT3mtkbJV2U9DpJMrOTkv4f59yDkmYkvd/CrQZJSX/onPvLmNYL7A8Lz4jOXlyRa2pkUcskYt8C1XaVt8ny8VzX5hDVbErOym1FbuCZbp4+0bm4DZwmrxSUW6vJmW3ETqd1OEnloUMQQma6dSKvySuFlvNCftLTyrHBm7OMQ+vIZfO583XlXvfC1uZQT8S3HvQJM82fGtHMxZWwW3Ajm6uZpFZinr/btjuqydLkkPyIebXrqtmkAlNbkRt4nm6cPtG5uA2cpq4UlN1GNpe22aciFma6NTusyaurrdncmCWMwyuWAtc5d0vSt0e8/4qkBxt/f0bSNx7w0oADV8smNXfPuIZXqkrUfVVzqTAYYu7eVxxpHc6+zlnYNKKbUj6leiqhZO321eLAwq6JeQCGIwAAIABJREFU5S7bicZvFpVbazTOaIwVcpLqCVPgSam62yiancKCeeX44Qih0khaV+8c08hCSdliXQk/UMJ3OnZ9TUtTQ4wMQuyOSja/7PNv1afmvyZJevCds5ylRaTqpmyu5FJ70tdht4ojmfBc7eY7sSatjXff+VUcSWtsPhHeyW28L2hcVK90ac40cWNN2e1kc8JUOH44ztyXRjO6lkko38jmpB/Iq5PNh11cd3ABNHGbzrD2g/JwSqV8WrnVMEjXtyYvTg0p6HKFWJJkpmtnRzU2X9LwSkVS2OV4ebJ72/2R5XJbaJvCq82X7zmm7GpVY7dKStQDlYZTWtniTvJB8OqB8stlJWqBKkOpcMtxh++xnkkq4Tsl60Hj+3QaXqkqt1bTlbvHFSSYvQfsh5aZtG8rKbrPFtCqH7O5lA8L7fWCcyObp4e2zpBGNo83stmph2x2Tvnl9ovdpvCs7dV7jim3WtVoSzZ3v5N8EBL1QMNL5XCG8RbZXMsklay3Z3O2kc2ObD50KHABRDPT/Mm8smvh6B3nmVbHMo0h8ltzCU9LM8Namhnu7fkac4Ajl9Jo9lDOp1Xe5oy7/ZQp1jR9KRyR5DkpWK5o7FZC1+4Yk0u0B2my4t++Q91gCr+/4aWyCjF3zQYGwfq2Y6lpLi3NoTAoGkebdpPNizPDWuw1m6XInhrS7UZMpXx62/Nn91NUNo/eSuj62TE5rz2bU5V65EhELwiL+7iPjGH7KHABdGZ2cEWlmSrZpDLleuvAeEmVXONHlXPKlOpKVX3V0onw/WZS4DQ+X1R+KRwXUM6ltDAzpHpmH3/EOafJK6stgei5sAnH6EJJy1PtxWq6Uo/8Up6TsqW6Cvu1VuAIePzR10uSHmEuLQbdAWdzNZtQptza0DHsgdFDNt8samS5IlvP5tnhPZ900Lqw6GxOVX2NLJS0MhmRzWU/spuy15h9TDYfPhS4APrGwuywZi8sS02d+51JCzPDMj/QzMUVpaq3Q7aWTuj6HaOavLp6+3yQpGyxphMXVnTl7vF92yaVrAXy/PZbzp6ThlcqkQVuvcN26kBSdT8DHxgw586HF4se9N58+500hwL2xcJMXjMXlzcaMW1si54ZltfI5mRzNmcSun5mTJNXCi13RrPFmmafXQ6P5OxXNle7ZXM1ssCtpb3IUUHr55Nx+FDgAodMsuqH51qdUymfVjW3u/msQ4WqkjVf1Wwy9uZWtWxS1+4Y1cylQssMuokbRfmJcIB9cySmKr6ObypupUYAB04jCyUtTfe+DWs7XJeXyXV4DavZhGrphNKVTYPltxjtAOD2TFqpaS4t0CeSVV/DyxVJTqV8RtXczn/FDrO5omQtUCWbjL25VTWX1PUzo5qeW5HXVDuO3yiGTaY2ZVqq4uvYtdXIbb/mnEYWy5EXgfdEt5epw8eq2aTq6UTb96EemmqiP1HgAodIfrGsiRtrG+dhRhfKWhvLaGFmeNvhl6z6mr2wHI4cWB9PlE7oeofzowdlfL4kr2kMgjkpU6pJrn3unidpaLWmwFP71iJJ6XL0luC94KcSkYEYmFTo1MnSTDfuGNWxq6saWq1JCq8O35rNx94sC+hXj7z6TeFfKGrRp/KLJU3cKLZk8+p4Rosz+W1/rWTF1+zFiGzucH70oITZrJZszhZrG3d1m3lOGlqtdtz2u5/ZXE8nVE8llKpuL5uv3zGq41dXlWvO5hP52JtlYWcocIFDwqsHmrix1no11EnDyxWtjWZU6TJ+J8rklYI8v7WQTFV9jd0q7ttdz61Y4JRbq0WGZYceF+HnRXzQKbwq26tELdDIYkmZYl21TEIrx7JbnuG9eWpEMxeW5bnbCywPp7rejQ0SnuZPj0qBkzlHd0agyf2P3SdJrXNpgT6WqAWauFFsy+b8UpjN291l1SmbR+eLWo4rm/0gLGY3vb9bNluHjwXabjb7GlkoK1Naz+ac6ltsG755uj2bS/l017uxQcLTzY1sVqwX+rF7FLjAIZFbrUa+35w0VKhuq8D1/EDpsh8ZVsPLlc4FrnPKFmtK1gJVs8lthVRPXLcytn2w/Pow+fW7vOu/YDhJzlPPg9qTVV+zzy5v3DnOlOsaXqnoxulRVboMq6+nE7p874Ryq7VwFEEu2XMnS3km13UvFXA0ZJ98aOPvr3gn43twuOTWumTzSnVbBa5XD5SuRmdzfqXaucB1Ttm1mpL1/cnmTl2UN55e7dlczKfkBWHzqeZsltf7tt9kxdeJ9Z1masrmM6Ndf+fZfTbjsKPABQ6LLluQt/vDeCc/vBP1QDMXlpWo3z6AU8kldeP0qLRH26ZcwlMt077t1236uyncbuQ808LMsIKkp/Eba8ovV2ROqmSTWpgd7nnb7/iNtdZt0QoD/fi1VV25e7z79m8zlUb6ZzwCcBhsbDuWGOGDQ61rnu4kGrcZ0Imar5mLK0r4we2dRLmUbp4Z2bNzu0HSC/tHVNs7KTf/vTmbF2eGFSQ8TdxY0/B6NueSWpgZlp/qbefSxI21jeJWup3Nx66t6erd490/mWw+0ihwgUOilI++WulMKo51OFfSgUt4qmaTSm8ayRNYOPQ9yvErq0rWgpbHZ0p1jd2KHomzU/Mn8pq9uCLnXMv2p80F7/JEVoXjuY0tvouz+dtz/bYZ6rliPfL3kGQtkAWOrUrAHsh/w4weeeWbtn4gcIiURtLS9bW29zuT1ka3l81B0lM1096IMDBpdTS6WJuMyOZsqabRW9EjcXbq1smwk7Kcumfz8awKE0Mbubkwmw/7hEjbzuaobdFSuGXbAhfrmWT0Nw5/AYdEkPA0fyKvwNTyZ/l4bkfbkeZP5hUkTEGjO37QaGSxHBGI5ruO52/yy+WdfUMd1LJJXb57XMvHcyoOJSWLvgiecGo/v2q2oyvWQaeQtM4dkQFsz5cut4/uAA67IOHpVkQ2L03met8W22T+1EiYzdaUzZlEZLFqfqBMqf0CreekkeXKzr6hDqrZpC7fPbGRza5DNntBxPnVnWZzh4vLzrpPMgC4gwscIqXRjC4PpTS0WpU5p9JwescD0+vphC7fM6GhQlWJxpig8vp5U+dawqjbiZStzubsRJD0tDI5pKGVirLF1bYQNUnJ6t51YVyZyGp8vrVJSGBScSS9Z9uvAQCDqTiaUbmRzXLhjquddsZvzuZkzb89Jkhqz+b1fcGR3Zz2Ppw3Z/NmYTb77Z+4Q4WJrMbmS23ZvDaaiXVsEvofBS5wyARJb8/msjnPNrYkJyt1zVxcUaZUl0xaG8loYWZILuEp6HI2dm0fz7hUM4nIK8ROkr+H3YcLx7JKVX3lVyoKzGTOqZJLaWF2+yMeAABHz35lc2pTNq+OZrQ4MyznWXg2NtV+NjaQVBzZ3vbo7ailO2dzp7uuO7FyLKdkNWjJ5vJQ6vZxJKADClwA8uqBZi+s3G605BQOma/6un7nmKT2s7GBSX7Si9zSvFeS9egtjSYpUd/Dq9NmWjiR19LUkNIVX/WUt+M74wAA7IX1bLambB5eqShV9XX9bJjN4dnYFWlzNk/l9m1dB53Ny5NDSlXrqjfmzwNbocAFoPxSWeZah9Z4TkpX6kqX66pmkxtnY4eXy0pVw7b7xdHMvjZ5cDI5T7KILHX70EEgSHoqM9QdANAHRhbLUlQ2l+tKleuqNUYCXb57XPnlspLVQJWhpIoj+5zNpshsDkf07f3z+ilPfoqOyOgdBS4ApSt+yxmXDSalKv5GE6sg6alwfP/u2G5WGUo2ZsW2Li6w3ufoAQBwGKUr9ehsVthJuNaUzSsHmM3loVRkNjuTVsf3b2s00CtuVQBQNZtQ0OFATTUT43YgM908PaLAU/jH1ovbzO2mGwAADKBKNhmdzQo7K8emOZubOkcXxrMqD5HNiB93cAFodTyr0VtluaatUIGFQ9l3MuZgL1WGUpq795hyq1V5vlN5OMUZHADAwFsdz2p0ISqbU6pl+iSbC1V5AdmM/kKBC0BBwtO1O8c0cX1NuWJNzkyro2ktTfdHp0LnmYqjbHsCABwdQbI9mwtjGS1PHdx25G6cZyqOkc3oPxS4ACSFs/dunhmNexkAAKCBbAa2jzO4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBEEuBa2avM7OnzCwwsxd1edyrzOxLZvYVM3vbQa4RAICjhGwGAAyCuO7gfkHSQ5I+1ukBZpaQ9FuSzkt6vqQfNLPnH8zyAAA4cshmAMChl4zjSZ1zT0uSmXV72EskfcU590zjsX8s6TWS/tu+LxAAgCOGbAYADIJ+PoN7StKlprfnGu8DAADxIJsBAH1t3+7gmtlHJc1GfOgdzrkP9PIlIt7nujzfw5IelqTM6FRPawQA4CghmwEAg27fClzn3Ct3+SXmJJ1pevu0pCtdnu9dkt4lSSMnntMxbAEAOKrIZgDAoOvnLcqfkPQcM7vLzNKSfkDSEzGvCQCAo4xsBgD0tbjGBH2vmc1Jul/SB83sw433nzSzD0mSc64u6ackfVjS05Le65x7Ko71AgAw6MhmAMAgiKuL8vslvT/i/VckPdj09ockfegAlwYAwJFENgMABkE/b1EGAAAAAKBnFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAixFLhm9joze8rMAjN7UZfHPWtmnzezz5jZJw9yjQAAHCVkMwBgECRjet4vSHpI0qM9PPYVzrn5fV4PAABHHdkMADj0YilwnXNPS5KZxfH0AABgE7IZADAI+v0MrpP0V2b2/5nZw3EvBgAAkM0AgP61b3dwzeyjkmYjPvQO59wHevwy3+Kcu2Jm05I+YmZfdM59rMPzPSzpYUnKjE7taM0AAAwyshkAMOj2rcB1zr1yD77GlcY/b5jZ+yW9RFJkiDrn3iXpXZI0cuI5brfPDQDAoCGbAQCDrm+3KJvZsJmNrP9d0ncqbIABAABiQDYDAPpdXGOCvtfM5iTdL+mDZvbhxvtPmtmHGg+bkfQ3ZvZZSf9V0gedc38Zx3oBABh0ZDMAYBDE1UX5/ZLeH/H+K5IebPz9GUnfeMBLAwDgSCKbAQCDoG+3KAMAAAAAsB0UuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBQIELAAAAABgIFLgAAAAAgIFAgQsAAAAAGAgUuAAAAACAgUCBCwAAAAAYCBS4AAAAAICBYM65uNew58zspqQLu/gSk5Lm92g5g4jXZ2u8Rt3x+myN16i7g3x9zjrnpg7ouQYW2bzveH22xmvUHa/P1niNuuuLbB7IAne3zOyTzrkXxb2OfsXrszVeo+54fbbGa9Qdr8/Rw7/z7nh9tsZr1B2vz9Z4jbrrl9eHLcoAAAAAgIFAgQsAAAAAGAgUuNHeFfcC+hyvz9Z4jbrj9dkar1F3vD5HD//Ou+P12RqvUXe8PlvjNequL14fzuACAAAAAAYCd3ABAAAAAAOBArcDM/s3ZvZFM/ucmb3fzMbjXlM/MbPXmdlTZhaYWezd0vqFmb3KzL5kZl8xs7fFvZ5+Y2aPmdkNM/tC3GvpR2Z2xsyeNLOnG/9//XTca+o3ZpY1s/9qZp9tvEa/EPeacHDI5u7I5mhkc3dkc3dk89b6LZspcDv7iKQXOOfuk/RlSW+PeT395guSHpL0sbgX0i/MLCHptySdl/R8ST9oZs+Pd1V9592SXhX3IvpYXdJbnXPPk/RSST/Jf0NtKpK+zTn3jZLOSXqVmb005jXh4JDN3ZHNm5DNPXm3yOZuyOat9VU2U+B24Jz7K+dcvfHmxyWdjnM9/cY597Rz7ktxr6PPvETSV5xzzzjnqpL+WNJrYl5TX3HOfUzSQtzr6FfOuavOuU81/l6Q9LSkU/Guqr+40GrjzVTjD80kjgiyuTuyORLZvAWyuTuyeWv9ls0UuL3555L+Iu5FoO+dknSp6e058QMQO2Rmd0r6Jkl/H+9K+o+ZJczsM5JuSPqIc47X6Ggim9ELshl7hmzurJ+yORnXE/cDM/uopNmID73DOfeBxmPeoXBrwnsOcm39oJfXBy0s4n3cWcK2mVle0vskvcU5txL3evqNc86XdK5x/vL9ZvYC5xxnxwYE2dwd2bxtZDP2BNncXT9l85EucJ1zr+z2cTP7EUnfJenb3RGcp7TV64M2c5LONL19WtKVmNaCQ8rMUgoD9D3OuT+Nez39zDm3ZGZ/rfDsGAXugCCbuyObt41sxq6Rzb3rh2xmi3IHZvYqST8r6Xucc8W414ND4ROSnmNmd5lZWtIPSHoi5jXhEDEzk/Q7kp52zv1a3OvpR2Y2td4518xykl4p6YvxrgoHhWzGDpDN2BWyeWv9ls0UuJ39pqQRSR8xs8+Y2W/HvaB+Ymbfa2Zzku6X9EEz+3Dca4pbo/HJT0n6sMIGBO91zj0V76r6i5n9kaS/k/T1ZjZnZm+Me0195lsk/bCkb2v83PmMmT0Y96L6zAlJT5rZ5xT+4voR59x/iHlNODhkcxdkczuyeWtk85bI5q31VTbbEdzdAwAAAAAYQNzBBQAAAAAMBApcAAAAAMBAoMAFAAAAAAwEClwAAAAAwECgwAUAAAAADAQKXOAIM7O/NLMlM2PMCgAAfYBsBnaHAhc42v6NwtluAACgP5DNwC5Q4AJHgJm92Mw+Z2ZZMxs2s6fM7AXOuf8oqRD3+gAAOGrIZmB/JONeAID955z7hJk9IemXJOUk/YFz7gsxLwsAgCOLbAb2BwUucHT8oqRPSCpLenPMawEAAGQzsOfYogwcHcck5SWNSMrGvBYAAEA2A3uOAhc4Ot4l6X+V9B5JvxrzWgAAANkM7Dm2KANHgJm9QVLdOfeHZpaQ9F/M7Nsk/YKk50rKm9mcpDc65z4c51oBADgKyGZgf5hzLu41AAAAAACwa2xRBgAAAAAMBApcAAAAAMBAoMAFAAAAAAwEClwAAAAAwECgwAUAAAAADAQKXAAAAADAQKDABQAAAAAMBApcAAAAAMBAoMAFAAAAAAwEClwAAAAAwECgwAUAAAAADAQKXAAAAADAQKDABQAAAAAMBApcAAAAAMBAoMAFIpjZU2b2QIePPWBmc10+991m9kv7trhDxMxyZvbnZrZsZv9+G593h5mtmlliP9cHADg8yOa9QTZj0FHg4sgxs2fN7JWb3vejZvY36287577BOffXB764Ljav8ZD4Pkkzko47517X6yc55y465/LOOX+vFmJmzzezT5rZYuPPR83s+Xv19QEAO0c2H6i+yeZmZvbzZuY2/3cAbBcFLoCeWGi7PzPOSvqyc66+H2vapisKQ/2YpElJT0j641hXBADALgxANkuSzOwehRl9Ne614PCjwAUiNF9JbmzleXfjrt9/k/TiTY/9JjP7lJkVzOxxSdlNH/8uM/uMmS2Z2X8xs/s2Pc+/MLPPNbYKPW5mLZ/f43p/zMyebqzhGTP7iaaPfcHMvrvp7ZSZzZvZucbbL22sa8nMPtu8/cvM/trMftnM/lZSUdLdEc/9vMbjlhrbx76n8f5fkPRzkv5ZY0vTGyM+9yWNu6orZnbdzH6t8f47G1dxk2Z2f+Pz1/+UzezZxuM8M3ubmX3VzG6Z2XvN7FjUa+ScW3LOPeucc5JMki/p3u2+1gCAeJDNG48dmGxu8puSflZStceXF+iIAhfY2s9Luqfx559I+pH1D5hZWtKfSfp9hXcG/72kf9r08RdKekzST0g6LulRSU+YWabp63+/pFdJukvSfZJ+dAdrvCHpuySNSvoxSf9H47kl6fck/VDTYx+UdNU59xkzOyXpg5J+qbH+fyHpfWY21fT4H5b0sKQRSRean9TMUpL+XNJfSZqW9D9Leo+Zfb1z7ucl/e+SHm9safqdiHX/uqRfd86NKnx937v5Ac65v2t8fl7ShKSPS/qjxoffLOm1kv6xpJOSFiX9VrcXysyWJJUl/V+N9QEADh+yeUCy2cxeJ6nqnPtQp8cA20GBi6PqzxpXNZcaBc+/7fLY75f0y865BefcJUm/0fSxl0pKSfo/nXM159yfSPpE08d/XNKjzrm/d875zrnflVRpfN6633DOXXHOLSgMpHPb/Waccx90zn3Vhf6TwlD71saH/0DSg2Y22nj7hxWGvhSG64eccx9yzgXOuY9I+qTCoF33bufcU865unOutumpXyopL+lXnHNV59z/K+k/SPrBHpdek3SvmU0651adcx/f4vG/IWlN0jsab/+EpHc45+accxVJ/5uk7zOzZKcv4JwblzQm6ackfbrHdQIA9h/ZHDoy2WxmeYUF91t6XBuwJQpcHFWvdc6Nr/+R9KYujz0p6VLT2xc2fexyY9tr1MfPSnrrpsA+0/i8ddea/l5UGErbYmbnzezjZrbQeI4HFZ4zlXPuiqS/lfRPzWxc0nlJ72la3+s2re/lkk40ffnm732zk5IuOeeCpvddkHSqx6W/UdLXSfqimX3CzL6ry/f4E5IekPT6puc7K+n9TWt/WuHW45luT+qcW5P025J+z8yme1wrAGB/kc2313dUsvkXJP2+c+5rPa4N2FLHuxwANlxVGHxPNd6+Y9PHTpmZNQXpHZK+2vj7JYVXmH95vxbX2FL1PklvkPQB51zNzP5M4TnTdb8r6X9Q+P/83znnLjet7/edcz/e5Slcl49dkXTGzLymYLtD0pd7Wbtz7h8k/aCFDTIekvQnZnZ88+PM7Fsl/StJL3fOLTd96JKkf+6c+9tenm8TT9KQwsC/sYPPBwDEh2zu7DBl87dLOm1m6xczpiS918x+1Tn3q72sF9iMO7jA1t4r6e1mNmFmpxWeZVn3d5Lqkt7caLrwkKSXNH38/5b0P5rZN1to2MxebWYjO1yLmVm2+Y+ktKSMpJuS6mZ2XtJ3bvq8P5P0Qkk/rfDcz7o/kPTdZvZPzCzR+JoPNL7PXvy9wm1J/9LCBhkPSPpu9did2Mx+yMymGgG81Hi3v+kxZyQ9LukNzrnN4fzbkn7ZzM42HjtlZq/p8FzfYWHTkURjS9ivKTwX9HQvawUA9BWyubNDk80KC9wXKNwCfk5hcf4T2qKfBtANBS6wtV9QuLXnawrPz6yfkZFzrqrw6uaPKiyW/pmkP236+CcVnvX5zcbHv6KdNapY9zJJpYg/b1YY9ouSXq9wBM4G51xJ4ZXkuzat75Kk10h6RGEIX5L0v6jHnw2N7/97FG6tmld4XuoNzrkv9vj9vErSU2a2qrCpxQ8458qbHvPtkmYVXkFe79a4fsX+1xvf61+ZWUFhk4tv7vBc4wobYCwrvIp/r6RXRTwfAKD/kc0dHKZsds7dcs5dW/+jsJBedM6t9rhWoI21Hk8AMKjM7OckfZ1z7oe2fDAAANh3ZDOw9ziDCxwBFs6fe6PCLo0AACBmZDOwP9iiDAw4M/txhdub/sI597G41wMAwFFHNgP7hy3KAAAAAICBwB1cAAAAAMBAoMAFAAAAAAyEgWwyNZ5Mu9nUUNzLAIAj5fL4VNxL2Ber174y75wbzG/uAJHNAPZC/htm9KXLQdzLQMy6ZfNAFrizqSE9du/L414GABwZj7z6TZqNexH75D/96qsvxL2GQUA2A9gLL/vkW/XA20pxLwMx65bNbFEGAOzKyz7/1riXAAAAIIkCFwCwC+fO17mSDgA4MJ+a/1rcS0Cfo8AFAOzY21/7hriXAAA4Qn7mnYN6IAZ7hQIXALBjn31iPO4lAAAAbKDABQDsyCOvflPcSwAAAGhBgQsA2Lb7H7sv7iUAAAC0ocAFAGzbK97HuBcAANB/KHABANvCWCAAANCvKHABAD172effylggAADQtyhwAQA9o7gFAMSF5oboBQUuAKAn587X414CAABAVxS4AICePOi9Oe4lAAAAdEWBCwDY0uOPvj7uJQAAAGyJAhcA0NX9j92nzz4xHvcyAAAAtkSBCwDoipm3AADgsKDABQB0lH3yobiXAAAA0DMKXABARz/zztm4lwAAANAzClwAQCTmDQIA+gU7itArClwAQJv7H7sv7iUAAABsW2wFrpmdMbMnzexpM3vKzH464jFmZr9hZl8xs8+Z2QvjWCsAHDU0ljqayGYAwGEX5x3cuqS3OueeJ+mlkn7SzJ6/6THnJT2n8edhSf/uYJcIAEcPd2+PNLIZAHCoxVbgOueuOuc+1fh7QdLTkk5tethrJP2eC31c0riZnTjgpQLAkXH/Y/dx9/YII5sBAIddX5zBNbM7JX2TpL/f9KFTki41vT2n9qAFAOyRt9ReEPcS0CfIZgDAYRR7gWtmeUnvk/QW59zK5g9HfIrr8HUeNrNPmtknl/zqXi8TAAbeufN1ffaJ8biXgT5ANgMADqtYC1wzSykM0Pc45/404iFzks40vX1a0pWor+Wce5dz7kXOuReNJ9J7v1gAGHAPem+OewnoA2QzAOAwi7OLskn6HUlPO+d+rcPDnpD0hkbHxpdKWnbOXT2wRQLAEfH4o6+PewnoA2QzgH50/2P36WfeORv3MnBIJGN87m+R9MOSPm9mn2m87xFJd0iSc+63JX1I0oOSviKpKOnHYlgnAAy0c+freoStyQiRzQCAQy22Atc59zeKPsfT/Bgn6ScPZkUAcDSxNRnryGbz6s+JAAAgAElEQVQAwGEXe5MpAEB8Xvb5t8a9BAAAgD1DgQsAR9gDbyvFvQQAAIA9Q4ELAEfUI69+U9xLAAAA2FMUuABwBN3/2H1xLwEAAGDPUeACwBH0ive9PO4lAAAA7DkKXAA4Yrh7CwA4TLgoi+2gwAWAI+T+x+7jFwUAADCwKHAB4Aj59F33xr0EAACAfZOMewEAgINx7nxdD75zNu5lAAAA7Bvu4ALAEfGg9+a4lwAAALCvKHAB4Ah4/NHXx70EAACAfUeBCwBHwGefGI97CQAAAPuOAhcABtwjr35T3EsAAAA4EBS4ADDAmHkLADjMyDFsFwUuAAwwZt4CAA4zcgzbRYELAAOKxlIAAOCoocAFgAF07nydxlIAAODIocAFgAHEzFsAAHAUUeACwIA5d74e9xIAAABiQYELAAPk3Pk6d28BAMCRRYELAANk6F//bNxLAAAAiA0FLgAMiHPn63rgbaW4lwEAABAbClwAGBBsTQYADJL7H7sv7iXgEKLABYABwMxbAMCgsRd/R9xLwCFEgQsAA4CZtwAAABS4AHDoPfLqN8W9BAAAgL5AgQsAhxgzbwEAAG6LtcA1s8fM7IaZfaHDxx8ws2Uz+0zjz88d9BoBoJ/RWAp7jWwGABxmcd/BfbekV23xmP/snDvX+POLB7AmADgUsk8+FPcSMJjeLbIZAHBIJeN8cufcx8zszjjXAACH0bnzdT34ztm4l4EBRDYDAA6zuO/g9uJ+M/usmf2FmX1D3IsBgH7A1mTEjGwGsO8eeFsp7iXgEIr1Dm4PPiXprHNu1cwelPRnkp4T9UAze1jSw5I0k8od3AoBADhayGYA+44mitipvr6D65xbcc6tNv7+IUkpM5vs8Nh3Oede5Jx70XgifaDrBICDxFggxIlsBgD0s74ucM1s1sys8feXKFzvrXhXBQDxednn3xr3EnDEkc0AgH4W6xZlM/sjSQ9ImjSzOUk/LyklSc6535b0fZL+JzOrSypJ+gHnnItpuQAQO84jYb+RzQCAwyzuLso/uMXHf1PSbx7QcgCgrz3+6OulJ+JeBQYd2QwAOMz6eosyACCUffIhffaJ8biXAQAA0NcocAHgEPgZZt4CAABsiQIXgCQpCJzqNSeO0vWf+x+7L+4lAABiQDYD29fvc3AB7LMgcLp+tabCsi9J8jxpajalsXF+PPSLV7zv5XEvAQBwgILA6fqVmgort7N5+kRKo2NHJ5sf9N4c9xJwSHEHFzjirl0Ji1vnJOck35euX6mpuObHvTSImbcAcBRduxwWt83ZfO0y2Qz0ggIXOMJ832m1EaDNnJPmb9bjWRQ2MPMWAI6eet1ptRCdzbfIZmBLFLjAEVavOck6fKzKeZ84nTtfZ+YtABxB9bqTdcjmWo1sBrZCgQscEs7tfZOJVNqkDl8yO8SPhzi9/bVviHsJAIAt7Ec2p9PWdvd2XY5sBrZ0dE6qA4eU7zeaQK34kpOyOdPsybQy2d2HnOeZjk8ndetGvSVMzZMmp/jxECdm3gJA//L91iZQuZxp5lRamcweZfNUUrdutmaz50nHyWZgS1wGAvqYc05zz1Y2iltJKpecLn6tonp9b64YH59MafZUSumMKZGQ8iOezt6dUXoPQho7Q2MpAOhfzjldWs/mhlLJ6eIze5fNxyaTmj0Zkc1pshnYCpeBgD5WLjlVKq5tG7Fz0vJiXcenUnvyPKNjySM1eqCfvezzb5U4ewsAfatcClSN6FOxl9lsZhodT2qUkX3AtnEZCOhjtWoQ2QTKOalcDg5+Qdh3NJYCgP5WjbjwLIXZXK3QBAqIGwUu0MfSWS8yRM2kXG57//sGgZPvE7z9LPvkQ3EvAQCwhU49MMykTK5D++MOyOZojz/6+riXgEOMfQ9AH8tmPeWGPJWKQVujibGJ3v73XW+EsT5TL5U2zZ5MaWg4sU+rxk5kn3xIP/PO2biXAQDYQjbnKZvzVC5FZHOPW4p93+nalarWCuHXSKdNs6dSyg2RzcBuUeACe6xU9HXzel2VcqBUynR8OqWR0Z0H1qk70pq/XtPyUligDuc9Tc+mlEj0dpX48sWqSqVg405wreo0d6GqO++hkVQ/obgFgP1TXPM1f72mSsUplTJNzqSUH9l5Np8+u7tsnrtQUbl8e6tztep06dmq7ryXRlLAblHgAj0orvlamK+rXncazid07HhSiWR7iBWLvuaerW5c0a1UnK7OVRWcSPV8x3UzzzNNn0hr+sT2P7dSCVRuKm7XOSct3qpr5mR6R2vC3rr/sfuk98W9CgA4XNZWfS3eCrM5n09oolM2r/mau9CazVcuVTVzMtXzHdfNdpPN5XKgSjm6geTSrbqmT5DNwG5Q4AJbWFqo6ca127PoqpW6VpbqOntPVslNQTp/rdY2nN056eb1mkbHEzLb3tmc3apVncwUOTA+qgMk4vGK97087iUAwKGyeKumm9dbs3l5qa4778m2Fbk3r3fJ5rH+yuYK2QzsGgUuBlpxzdfyYrh9aHQ8oeG8t60gCwKnG9dbB607J9X9MFynZlqvslY6dE/0AykIpMSm3VCFFV8L8zXV69LQkKfj08k93ZqUyVpkgJqFZ4gQP2beAjhKnHMqrgVaWdpdNt+MyGbflxYX6pqcbh3TUyl3yOa65ALJtsjmyemkUgeUzUNDZDOwW/xfhIF181pVcxeqWln2VVjxdeVSVVfnanJRqdJBpeyipvRITlortI/pSaaiA9osbD7RbGG+pqtzVZVLTvWa08qyrwtfrYSjgfaAc07lklMi4jKWedLEca5vxe3+x+6LewkAcKBuXKvp8sXWbL52eXvZXC4HiqqHnZNWC37b+ztls+eFedjsVkQ2P7vH2Vwpu7YL3uvr2elxJgC3UeBiIFUrgRYX/Laru6sFX6Vi7yGVSEZvIQo/1h6Yk1OpttA1kyaOJVuuTgeB0/zNetvXDgLp1s16z+vrxDmnyxerujpXVb3W+rGR0YTuvDvTtr0aB+vc+TpbkwEcKZVKsLGrap1z4R3Tcqn3AjeZiL4DKiky245PJaOz+Xh7Nt+60SGb5/cmm+cuVHX1clX1TV9uZCyhs2QzsCcocDGQ1laji1jnpLWIq7udpNOeMtn2sDGTjk22X2UdGUtoejYpLxE+Zv1O6eR062NrXc7YFLdRgHeythqouBa0hbSZNH0itadbrbAzb3/tG+JeAgAcqLVCEDXavXEBuvcCMp3xlM70ns1j40lNbcrmY5NJHZ9qfWy14iLvDEtSaW332bxaCFQqBXKbvpSZNDNLNjf77BPjcS8Bhxj7INCXgsBp8VZdK0u+ZNLYeCK8C+r1dmVz83bgZr1+jXUzJ9Oae7Yiv6kuPj6V0HA+erzA+LGwY3LgqxGm7c+XSFpb98R1nbZSbUdh2Y++um1ScdXX6A67RmLvEN4ADpvIbN50F7Qbz5NMEfFn6nm8zrrZk2ldulBR0JTNk9OJjjPeJ46lND6RlO+H/TCi1pxMdrkzvFfZHFUnm1RcCzQyxgxcickC2D0uFaHvOOd06dmKbt2sq1p1qlac5m/UNXex2vMZneF89H/aZmFDi175vtPchdbi1kxtW4ua116rObkgLGI7hX4yaY2mGu3rOx5x9Xm7OhX4pu0X+Nh7NJYCcNg453Txa+3ZfHk72TziRTdXkrZV3Pn1MJuDTdlcq0U/vjmbk92yOWUaGu6QzVN7kM1dvsXNZ4EB7Bz/O6HvrK0GqlRc2xmdUjHo6fysC1yjGG7/2OR0YltdipcW6i0Bur6W5UVf9VrrExSW6/rql8v62j+U9ZUvlXXlUlVB0Dn0T5xOa3gkDNL1JlTTJ1Id7wxvx9hE+3mjdZ2K/174vlO9zgiD3aCxFIDDaK0QqFptz+biWtDT+dkgCM+fRpmaSSqV6j2bFhfqCjb9OrCRzZsyamW5rq9+qSmb57pn88nT6Y0L0OvZPHMy1fHO8HZ0ymaTNDRMNgN7hX2K6DulYvQWHuekcinYMmRWVvyOIwFWVwMdm+x9LVHnWKUw9MrlQPlUorHmQFcvt87ZWy34unLJ6fTZTOTX9jzTqTMZ+b6TX3dKpTtfVd6ubM7T1HRSN2/UJdNGJ+hTZ9PydnAHt15zujpXVbEUyBRe5T5xKq0c4wy2jcZSAA6jYpdsLpWCLfNgZdlXtcMovdWCr4njqciPRa6lSzZXyoGSjQvFxaLf6NDc9Fwrvq4GTqfu6JDNCdOpOzLy606+v7fZnMuFI4fmG9kshf84fTazo2yuNbK51MjmVDrMZsYA4qijwEXfSaU8mbWfITUvujviZoXlzk2kSmtOzrnIsKrXnAorvoLAaTifUDbnKZU2aa396zjXeh5nYT56iHxxLVCt5pT6/9l70xjprvS+7/+cu9W+9b69/S7kjBJLFAGN5JCZIGSCOOKMAwmMIskDWFAURI7GhmQMAXlEAwqCIOPIGANOIFuiPxCCBY01AShEDKxBAse0E2McWIoyFCV5pOHwXXrfat/udk4+nKrqWu6tpbuW7rfPDyD4dnV11e2q6vu755zn/J8he3c0jSbeezQO2WUDyYyOes0HY7Ls6ioCFULg2RO7E4wlIEOy9p7aePhCZCr7ku4Kr370FvDlxqIPQ6FQKCZmuJtH/3ylFB4iVa+Frz56rkC57EN0udk0CY364H2F6L1OyAd0KxBCVop5nhh6TaHpFNgt4brklg2kpuTmvcc2XPfSzY4tt3g9eDGi0pgVdxo1wFXcOJJpDWcngwNGIiCRGl0idJXBYqXk4ehAbt4RQrbqSaU1ZJa0TjP6bkyLEIlczpCGpSITSTkbBqFW8ZG/8OD7AomkDOaYxcC2G10npNLX+zNv1Hlw6ZMASkUPSyvjz7rfZV796C28pga3CoXilpJKazg/HXQzIyCRHNfNk5XRlksejvvcnM5oyOQ0lAPCFK0IwZrAzbpOqFZ8FG6hm+s1Dt8f/P1kqbZys+Juo2oYFDcOTSPs3LdgGNTZA2OahHv3xyvhyeTCRZtMsYHVW+6LTnlxW5ZCyHIq3wO2dkxoOjrHEouznrJjIUToKqYQcjB8cebiYM9BvcZhNwXy5x6efLcZKKebhuuIwGsSIRBabqYY5Be+ebToQ1AoFIoro+mE7d0+N1uEnQfjujl8QJdKD16O+r7olBd3u7lU9ME5sBnk5nsTuNkknJ+6OOxz89Pv2rfGzUFl2kIMb0WoUNwFFrqCS0TvAvjLAE6FEN8b8H0C8D8B+ByAOoCfFkL84XyPUrEIIlGGBy9acF3R2lci5SeEPKFLoUlxNRsc+XMPrssRizNkl4zLPS591KocZycOllaMjpBrNQ4iBJYxlYs+NrZNPPpUBJ4rQIx6yn44l6mSdsBAr91EHpCzzv3BHL4nQ6xu2iyr63JcnHqoVX0wjUKTLYmAaEyVQI3Dy294eFu1BVLcEpSbFWFEY9dz89KKhouzwW1E1Yp08/KK0Un6r1eHu3l9S7rZdQU01ltOzH25tSbMzbllHUIA+fNBN3ueQKngIbd8w9zscJyfeqjXfGgaIRlS0SbdfLvXr1RWheK6LLpE+TcA/CqAfxzy/TcAvNj67y8C+LXW/xV3ACKCaV4Kq1L2cHbsSbEyIJvTEYkSjvYvS6aaTR+lgo/dRxGksxoKFz7y55cDXc6BwoUMoQoLfwo7FsMcHMxdnHlyFbPfoSRTF1NpDfUhA+hahWNpZezDuPw9fIFyyYNtc0SjGpJpbSohGJ4nWrPX7RsE8mcedF22Rur+HTSdVD/dMfkc+/lFH4JCMQm/AeVmRQhBbj499lqTwEBuSYdhAieHl4NHu+Xm+48iyGR1FPLTc7MZ5OZzN9DNRMD6poHkCDdXK5MFUnZ+D1+gVPLg2BzRmIZkakpudgWefHLZFsnzBJzzYDfrevjEtEJxV1jo1akQ4v8iovtD7vIjAP6xkA3W/h8iyhDRhhBC1frdMeo1H4d7lw3uBJczrwNyEoDvAxenLta3TGiaP3CfdviT3eSwIgzxRHBfPgCwbdmaKGw2tBKwBwhoR/5LsQ1rHK9d4S/Qbvp4+sllG6QiOI4OXWxuG0gkryfTwrnb0/MXaJU7uUBuWUOlxMGF3Ke0vGpcKRjjrvH1d74AvL/oo1Aoxke5WTEuteqgmy/OBt0sWm4+P3OxvmmCsSFutjksiyE2zM3N4W4uF4NTlgEglpCe1LTpurnZcnN7UF3McxyTi40dA4nE9dycv3ADWxa23VwucQghkExpWF5RblYobnoNwxaAva6v91u3Ke4Yx4fBvfPC5FSryl4GjfrwVgKAbNcT1nzdbspEwmIhpHv8ENp6sSIscIYZkCVc7eMYl/2nAT1+BXC458rvDenvN4p6SJ9hxoB4QsPDT0XwwqejWN80VULjGLz8hocPVWmy4vlDuVkBADi5qpsbIQNQApxWmz9No9B+7s2Wm0uFkGTmMfRkRSi0w0GzIeDYE7r5iTOwYiwEcPis5eawF2UM6rVwNyeSGh613Ly2Yc4k+VmhuG3c9AFu0F9p4BmCiH6WiP6AiP6g6AefcBW3E7vJ4U74lmqtAasVYYGCFAIwrMu9Q3549wIIAZwee4GN4dNZLfDxTYt6wi22dy2YAVVXngfsPbF7BqWex3F86ODJd5s4OrDhOpdi476AN+RYG3WOQn7IHUZgGMGnhP62SIrxUKXJiucU5WYFmk0Od8K5346bLQr9FLW3A3EuwIeMMaWb3WA3Z4a4uTUAJCJs3w9xsyvzNboHpcPc7PtioPqpm0ado3gdN4dMkve3RVIoFJKbPsDdB7DT9fU2gMOgOwoh/pEQ4jNCiM9kNHMuB6eYHYLLnrQXZy7OTiYzKBGQXZb1RZmsHig5yyJEIl3fGOEHAgJXWrNLch9w+zmIpMA3t3s/g7oR3hJACKDaWXH28d0/s1EqyL1I5SLHJ9+xUa14Yx1nO2HyquSWA14vQqvv4E0/XdwsIh+8uehDUChmhXLzHUVwgUqp5ebjyd2ca7s5Z2Cgipbkqmokyjr3H4egIKncsg4rQqCWtogFu9kwCMlUuJvbK871WrCba1Wvdd/hq7Oydc813LxkBLo5GmOdoC+FQnHJTU+IeR/A3yCi34YMsCipPT63GyEEbFtAYwg9KXuuwNPHMqZfjKgQiicInBOajcuwiGxOQ6oVsKAbsoXByaGDZkMKKJnSsLZpdPbDEBEyWYZiPvzJhABYQF88xmRLo0ado9HgMHRCIqUF7n/x3GABtlMbhRDYfxq8wnG45+LFf0c+blAoRv/jXZVIlGFz28TxkdPZ7xOLM2xsqwvTSfnSV9cXfQgKxaxQbn7OGMfNrivw7JMmOMfQlVUASCQJng/YDXHp5iW9k/xrGNKdx4cO7KYAqOXmjcvkYiJCOsNQKg53sxZwuIwR7j2wUK9xNJschkFIJK/u5oNn4W5+4Xs06DqTE9DD3Bz+rZFEYwzrWwZOj9zOax9PMKxvKTcrFEEsuk3QPwHwGoBlItoH8N8CMABACPHrAH4Psg3Bx5CtCP7LxRypYhqUSx5ODl15km/1h926Zw3sgTk5ckKF08/ahgnDZHBsDs8TsCw2sP8kEmHYfRgB56KnhUE3K2sGink79HlMk2BZwdInIsTiGmLx4amFsYSGUjE4lCoWY3Cd8HKsds9ZK0JY2zBwfBg8c04kS7OuQyKl4VFStkViGs284f3zyNuf/+KiD0GhuDLKzXeLfjdbEcLWjjWwLeXk0Bm6Raab1Q0ThjHCzVGG+49GuHndQKk4xM0WwRzi5nhCQzwxys0M5ZDAyGiMwbHD3cy57DlrWoS1dR0nR8Ev0DTcnErLCQLlZoViNItOUf4rI74vAPz1OR2OYobYTd5p2H55m8D+Exv3X7A6YhNCoFoZHexAJFdq2zPNpsUC99F0MyxVkDGGpRV9oCceAOg6sLV7/VnSRJLBtAiOfdmcnUgGRFgRNjJsirUcns7q0HXg+MiF1zXOpVZ5V7v37nUIa4ukGM0r774EvLfoo1Aoro5y892h2Rh0c7MhsPfUxv1HvW5ul+sOo93/vZ3ncF03axpDbllH4SLAzQawdW/8lkJhJFMa8ufegJuTKQ2WxdBsDP+92317MzkDukE4OXR7JgKIyW1RmZxys0IxL256ibLiOaGQH5QTIEuemg2BaGy8E3YkSmCMkM3piCenu+9kaUXuP82fe+Bc7tfJLumtfanXFwqRLJkq5D1Uij6IyT3CqdasrmkRGAsu/dK03rKxeFLHo6QO3xcol3x4ruy5F0+wqRyr4uqoBvUKheK2EOpmR8BuCkSio33SnlxlTE6wJpLT7cG6vKqDGFDodvOyjtzSlN184aFSark5p3e2OrX38gZtmdJ09FShJZI6Ep/W4XsC5bJy81VQFVCKaaAGuIq5EFZyTCT3uFx+TYgnWOBMcTKt9QRECCHQqHP4nkAkxq6dJEhEWFoxZAiGuJyVHRfOBewmB2ME06JAmTFGWFo2sLRsDHyPiLC5Ywbuw92+H7yCrGlysK+4GajVW4VCcZuYxM2xBEM9xM0bW71ubjbEVN28vGJgaVmXeRhXdbMWvtWIMen/pZVgN28FuZmAeyHVXZqu3KxQLBL116eYC7EEQ7022PdOCCAa7RXO+qaJp5804XM5Y0oM0DXC6vqleFxXlje7bleARU7D8ppx7VlSopD2BUMoFT2cHLkyY0LIGd2tXXPi5OF4QsOjT0eQP3dh2xzRqIbcsgbGVEriTeeVd19Sq7cKheJWEU+wwH7xQqCTZtxmfdPAs0/sXjfrhNW1Ljc7HHtPHXie6Pgwu6TLVdgpuHnShygVPJwcd7nZJGzfMydOHlZuVihuF2qAq5gLmYyOwrnXuy+FgExOGwiy0A3CgxcjqFZ8GaxkMSRSveU9B89sOI40clvMhbyPSFRDMj3d8qhRNBtcBnSIy5RExxHYf+LgwYvWxFLXdcLqukpGvG38fw9eWPQhKBQKxUSkszryF15PL/h2xkX/yqthMOnmsg/HEbAiDIlkv5sduG03t24rXHiIRFknQXleNBocJ0d9brYF9p46ePCCcrNC8TyjBriKqdKoc5yduLCbHLohy4oSKYbTE3cgfTG3omOp1RNPCIF6jYP7QDQuS5rC+sY6DocT0PdOCCCf9+Y+wC2G7GHyfIFmQ+6/UTzfvPyGh8+ptkAKheKG0qj7ODvxLt28aiCRZDg7dnsGt4DMo2j3qxVcoFbjELzLzZkQN9u8M/HcjRBykDvvAW4xIJgKkGXZ4+4vVigUtxM1wFVMjUaDY++J3RGKYwscHThIVTWUS4MNzot5D0vLOpoNjr2nNtCeZRXA0qoeuE8VaIUwhfSb4/51Os1dje59St0QMHDhMClCCLiOgIBsVaRCKm4mn2M/v+hDUCgUikAadR97T5xeN+87SKXD3Zxb1tGoc+w/szuuFUIGPuWGuDmsT/uNcjOFf29c2m4GZNmzcrNCcbNQA1zF1Dg/cQP38ZSKgwIFpAwbdR+Hey54310uTj3EYixw9dOyKHB82265M2/iQ/YXR2JX359jNzkO9i57Ams6sLltIXqNx1RMn6+/8wXg/UUfhUKhUARzdjK4kjnMzT6XW2/2nzkDbj4/9RCLawP7cwHp5iCIMPfKKgCIJ8P3F/dnf0xCs8FxuOd0BsmaLgMir/OYCoViuqi/RsXUaI7o49oPQfbbC5rtFQIoFoLlS0RY2zR6wiaI5P6YdlnVPElndRgGDRxPblm/cnok5wLPnthy9VbI18Nzgb2nNvxrzjxfB+4L2DZfyGz8TeXD9zOLPgSFQqEIZVSP9X4IcrtRUJWUdHNwaRKxEDcb0+kBOymZjA49xM3aVd3sC+y1Ai4v3SxDL/0FelG5WaHoRa3gKqaGYRDsoJNrSDkxIMUXdjoedqJOpXVYFkMh78F1BeIJhkxGB9PmXybEGGH3oYVCwUO15INp1+8FWC37gQN/CKBc8pFduv6frhACniugaTTydRNC4OzERTHvd97PTE7DyhRSq28zr370FvDlxqIPQ6FQKELRDQrMrRjl5jD84LlnANLNpsVQvPDgegKJBEM6q0/c2mcaME26uZj3UC1Px82VSrCbhQAqJX8qA3nBBTxPQNNp5OsmhMDpsYtS4dLN0+oooVDcZtQAVzE1llcNHO45PSd/IiCT1WDbAo0G7zRKJwI2tk1Zbivcgccap6TJijCsb04v0dBuctRrHEwDkkltosEy08L7214FzxOBTeWFADxvstn4IAp5F+ddZWtWRPYfTiT1wNKzi3MPxXxL7K2fKeZ9aBoF9g28C7z60Vt4TQ1uFQrFDWd51cDR/qCbszkNjYYMQxQCQKtD3sa2iUiUQYS4OTUiLCoSYVjfmr6bNQ1IpLSJBsttR03LU54bXnXmulNw87mL87MuN0cJ8fgQN595KBV63VzI+9B0Ct0rfZOJfPAm8NVFH4XieUANcBVTI5HUsLZh4OzEhc+lKNsziQBQq3LUqnJQlM5onT502SUN+fPLKWEizLWlgBACJ0cuyu39SAScHrnY3jUXloAcjWkgGtw3RQzXPqZK2cfZce9jNxsCzYaP/LmPZErD2qbe6jkoLyQKAWmU7WTMuzrAVYNbhUJxG0imNPgbOs5PvE5IYzYne9MCl26WCckaDEO6OZPTULjodXM0Jtv2zQMhBE4O3csgLALoyMX27uKyKKIxFhikRQTE4tdzc7nk4ey0z811gWZdujmV1rC6MZ6b8+ferRzgKhTTQg1wFQO0S1cZo4n3qaSzOlIZDdwHmIaeEplEUhsoDTo9dmTZaxfzLn2tVjjKxa6yo1aa88EzB48+HZnpcXieQK0qf/9EQuu83pEoIRbvDa8ikiEe8cT1xH5xNhgG1ka0SqDbFxTxBMPahjEQNNJmWKna84wKllIoFPOm42aNoE24HSeTNZDO6GO5uafstYvskhwUz9XNpSA32/N1c1LrvN7RGEM01tWskfUAACAASURBVBte1Z6Uj8Wv6+bgtkbAZShYOxgsnmBY3TDkhEUAd9XNCkUbNcBVAJB7PooFr7WnFdIiBMRiDBvb5kRhSUQEbYxPVr3mX5a9dlHM+1heMUBzWjwtFYKlwoUM2rjurGwYxYKH06PLErATuFjfMpBKywuIrXsminkPpdbgO53RkMld/+Kinco8DrUqx9NPbJhW8B6usNTM55lX3n0Jb7+ngqUUCsXs4Vyg1Haz07qRgFicYXPLnGgSenw388uy1y4KeQ9LKzrmtbUzrMc8F5hpj/li3sXpsdfZ09rv5u3dSzdDAKlpuXmCAMlalWPvsQ3TpMDew1bk7rlZoehGDXAVEEJg76kjUxN7viFFt//Uxv1Hkak/b8+qaTcE1Gp8jiXKwbfTkO9143sC5ZIPz5OD4VicjRSd63CcHg2upB4fuIjFNei6LEHKLhnILk23zCgSZahVx98rxDmQTjAUnN73iwhY3ZhNCRTncqVCN0aHbMyb19/77KIPQaFQ3AGEENh/aqNR769BBepV2aN29+H03VwKcTNBXhPMqx3fdd3seQKVlpvjCa1VXjzcJ47NcdrewtP1HHNxc0RWbY2L7wPJNIObD3Dz+t1zs0LRjRrgKlCr8qEtfhxbhlAEBRxch2HymifpjBbYKw/AyH0+9ZqP/WeOLJ0SMtwhGmXY3jWHirQclpIMuUc2O8OWCitrBuo1e6wLBACdVgj3Hlg4P3Vh2wKWRVheNWbwmRC4OPOQP79sQ3GT0ppffiO4PYZCoVBMG+nm8BO13RSwmxxWZMr7UYe4YVxvTIN0VrsMwOpjVM/Zes3H/lO55C3zInzE4gxb90a4uRTu5mp5OinJYaysGXj2eDI3EwE79y1cnEk3RyIyVGsWbj4/9VC4uHSgSmtW3GTUAFeBes0PTOxtQzS6dMbzBFxHwDBp7HLmVEZDJWCgJwSuvZdlEpJpDeWSj3q9lfLclSQ5bIZSCCFTo7teO8FlWXOx4CGbC59BDXu9BWS5+CzRDYJpEewhF07dEJOJ1ZEow/auNdNjK+Tl4Lb7M1HM+2BMDqgXyctvePgc+/mFHoNCobg71KpjuNkVsIYs4l7VzdWAdjhCAPE5ujmV1lAu+pcT0F1upnHcLLpvk6vP5aKPdDb80lcMGV3OenBvmATDApzmePeXuRxyT/DM3XzuDQRaFfKy9dJdDZpU3GzUAFcBTafAVMA2QiB0hrg75bD9GMm0hvXN0bN6sTiTAmvPmLbktb5pTBygcR3a+13rtcuU51RGhzGkDyAgZ8+DxqJCAGcnHjxXIJMzAh8nkdQGBnKA/P2nXf7leQLlouwXHItpKJc82AH7aaMxgucCbt8eXY2Nbtk0LYJek3Za86IHuLG/+7dUz1uFQjE3dJ2G9qod5ebjQxeVK7g5npBdDDoT0G03bxlz7TXf3u86qZubjXA3nx67cByObM4I7PWbSOkoXASv4saT0x3c97g5rqFUcOHYg/eLxQmOM5if0W6bNA/yqpOC4pahBrgKpNM6Lk6DSy+J0GobECyUizOvM0Btn/wqJR+6DqysDe+DR0RY3zKRznHUKj5YayDVblEwDXxfllczRohEKVTsRIR4QkM8MYEshjhWcCB/LkO07j2wBi5CIlGGdFbrCfIgAnLLOkxrer9/s8Gx98TuvD9BwSFtXBe4/8jC6ZGLSrk7qXH4SvY08UMqgDmXF2yLKoV6+Q1PtQVSKBRzJZXRZbJuwPeIZAlv0CANAM5PPVQC3GwYo6thpJsNZHI6qhUPmkZIpkcPLCdhlm4epgnOgfxFy80PLVh9vo0Oc7M5PTc36hx7T+3O9qahbnaA+w8tnB53uTnJsLY+RzcP6aQwTTd/6avrU3kchUINcBXQDbmCebTvtAYS8nbDIGSXNWSGlPMEpRwKIctKV9bGe/5olI3cT3MVChcuzk48OXsN2fB9Z9ec2gDSsggaA7whJWScAydHLu49kOVDL7/h4Zd+9Kc634/98Qmy/+wTCEYo/KVHaHzPSud7P/HXvnat4xNC4LD1nl7eNuRYfQFNI2xsm9i41jNfHSsSXDptmOEXQPNAlSYrFIp5Y7TcfLgvt8J0uzm3rA0ttQ1z87jVMESEaIwQjQ2fqL4K+XMX56eXbtY1uVI7NTdHCIwBfpibhUxiPj1ysXN/sLR3dd1AMq11Vr9TaX2qe1rbbhbjupkLaPqC3WxRYOWXaU3PzSrjQjFN1ABXAQCIJzQ8+nSkM7iwIuOdtMJm9Ra94tao+zg78Xpmrz0u06IfvmhN5biICJv3LOx3rZAG0WxwfP2dL+DD91utZXr6p2aAh5+W//zz1n8tPvz8FwEAv8f/Z3zrG5P/qXqumKgl0ESr1zNidd3A/tPevVNEwNqM0prHQfW8VSgUiyKe0PDCpyNoNkWnF/oofwkhQvujht0+L+o1H+envW52ucD+UwcPpujmrR0L+0+HuzkssZiIEItpiM2oDZHrCvgTtASK3QQ3bwS7eVZpzQrFdZlfWoDixkNEiERlmNC4kolEg+837gB5VhQC+usCl2VR0yIaZXj0qcjQAZhtGJeD2yvwOfbzeLs12J2EcV9/IoBpwPLa4ue7YnENOw8sxBMMuk6IxRl27psLHXxf571TKBSK60JEiEYZIpHx3ExEoX1Qw5w9L8J623qeGDv4cByiMYaHn4pgdSPca2xBV8DjXhoRyX22K6s3xM33LcTi3W62bsTEuEIRxOL/ahS3mtUNE3t9sfaTrLh5rkCl7KHZkE3nYnENybR27X0lYbOjhPBV56vCNEI6q6PZ5AP7aDxNw8ff931TeZ63P/9FfOWf/sOx7x+WlkwkW+9wDjiOQDTKkF3Sx07YHIUQAtUyRyHvgfsCiZSG7JI+dnBYdA5pzePyyrsvAe8t+igUCoViMtY2zE7+Qhu54jZeybHrClTLHhoNDiIgFpuOm72QKlQiOQE9TTSNkMkaaDYEysXBXrHp7GIGZ4bBYJgExx50c3ZJg+/Pzs2Vsi9DtLhAMq0hm9PHDg6LxlhgSbdCcRNRA1zFtYhGGXYfWcifeZ1+fLllfay+fIW8i7Pj3tncconj/NTFvYeRawVaJFIssLetEKN7216V//ivEv6PP95E4V+egjMGxjmO7u3g//0P/4OpPcekg9zNHRPPHtuyLK31WkRjbKZ9ZU+PHRTzl6vkdiuI7P4j61Y1hn/l3Zfw+nufXfRhKBQKxcREYwy7Dy3kz7vcvKIPhCoFUTh3cXba5+aidPPuw0hosNU4JFIssLetEJh679Y2q+sGXEegUeedROlYnC00mX+r5ebuEur2Mc3KzSdHDkqFLjefSjfvPrxdblYoxkENcBXXxrIYNrYnC6JwbD4wuG3jecDpkYOte1efKUxndJQKPhxb9CQhLq+Ov5I4CbJH6i8APwCkHuSRvsijtJRDOZeb+nNNMsg1TVlCXa1weK5AJDabQK82doP3DG7buI5AqeAhu3R79uuowa1CobjNWJHJ3WzbfGBw28bzZJudzZ2rB09lstLNrtPr5pW12bgZABgj7Ny3YNsc+OV/D79nrsLZTo38uesGPQ7DtFpurko3R2NsZgN8AGg0/J7BbRvHFiiX/KFhogrFbUR9ohULodP7NoRa9Xr7ZBkj3HtgoVT0UC1zWaqU0xCLT78kqX9/bDk3m4Ft/3OOO8glIiRn0CuPc4FahcP3BWIJBtNkOD1xQ+9fq3Jkl6Z+GDMh8sGbwFcXfRQKhUIxXyoj3FytXG+PD2OE3YcWSgUP1UrLzUuzC3SKfPBmb+uZP279/w9H/2w76PGD//xf4V//zB9N/diIzc7N1YoP7qPj5rPjIW6uqAGu4vlDfaIVzy2MEbI5A9kZjTVf/eithfZGjXzwJpqv/85CnrtR5zKhEuiUPqez2tAAL3ZLsihefsPD51QvPoVCcQcRw0a3GD8gaRiMEbJLxkwmPF/96C0AuHTzFCYqX3/vs8DnP4t/8T9G8c3v+3vXf8AZEuTmTE4bGuCl3RA3f/sXf1xNLCumhhrgKhZCIqkhfx5cBgUAqfQNOeP2Udcs/FnyAb71H30//oefKwJJE1jQ3pUvfXUdX1nA8wohcPDMHmg3USr4Q1Mps7dkhlj1vFUoFHeVZEqXIUQhbk7eUDf/k7/3V/D0f7Gg//QZmlEDSJnTGY138dqXG8CEORjzRAiB/QA3F/M+aIibM7mb4eYvqYllxRRZaJsgIvphIvozIvqYiL4c8P3XiKhERN9q/ffLizhORThCCDgOh+PwkTO/3USiDJmcFugfyyKs3MDeaidWDr997/P4N6vfD+dDIHdcxcaTIii0m/zsuUr7oKsihECt6uNo3wlMohZCrtIGvaemRYjOoDxcoVBMH+Xm20/bza4zmZ8iUYZ0NsTNEcLq2s1x88tvePj6O1/Af/f6f43ir3GkLxpIFm0sHVex8bgEmnIqc5u3P//FzkrxTaDbzTzEzVqIm60IIRJVblY8fyxs2oaINAD/AMB/AmAfwO8T0ftCiD/tu+v/LYT4y3M/QMVImg2Owz0HXqslj24QtnbMsRKUAdmuIJXmKJc8eK6AYTDEEgyx+Ph9eOeFAPDNz/ww3GMfaAmECUB3pVSLq/GFHdurH70187IpuWrroF7nEEOul3SdYFnUs4daNwg7uxYch6Ne5WAakEhoY7cmmCcTTxgIgWS+iVSxCfIFGnEDxdUYfENdMChuJ8rNt59+NxsGYXMCN69tSDdXypdujicZorGb4+bIB2/KrSS/K7B1WATrGstKN/tI5RsorcRm8vyvfbmBfzEH945CCIH9p05g14huDINgmoR6jffctt3v5uT1W0HdCIRAMt9AqmCDRMvNK8rNd4lF1iX8EICPhRCfAAAR/TaAHwHQL1HFDcT3Bfae9JbCuI7As8c2Hn06MvYJMhJliESvnsg4L77nn/8Cjn/2eKDkgQkgVnYWOsB97cuNmZcql0s+6rXhApV9BXWkMzrsJkezyWEYhGiM4fzERSHfmhkggOBi6545k9Cvq/LqR28BE+6pXjqqIlZxOhdX8YqDaN3F4YMMuL7QAhmF4qooN99igtzsOALPnth49Knx3RyNMURjN8/NnUnI1l5N3eVgAVVUTADxsj2zAS5wMwa55aI/cnDbdnMq3evmSJRwfuqi2HIzEXACF9u7JqIzCv2aFwNuLjuI1lwcPsyAa8rNd4FFvstbAPa6vt5v3dbPK0T0IRF9g4j+wnwOTTGKsKRFAaBSvlrKohAy+e9oz8bBMxvlckhH+Dnz6kdv4b/4FRuhlwU34Fz59Xe+MNPHLxeHJ2sSyQui9t5pK8KQzuiIxTXUaxyFvN/p9yc4wDlw8MyB4LMpIWs2OE6PHZweyZntcZg0MExz/R6BAgABIC6QKDYneiyF4gah3HyLCetQIPjVE5B73Lxno7IAN0c+eDOwwkYMGa+LOaw2v/blxkLLlUuj3Mxkf912WnO3mxt1gWKXm3nLzfvPnIm2nE1C4wpunhTdGeLmgnLzXWGRK7hBZ57+v6g/BLArhKgS0ecA/K8AXgx8MKKfBfCzALBmRKd5nIouhBBoNDhqtXCJeu7kJ0YhBA72HNQqlye8aoXjTL9+Y/nr0ElK1hkcS4PZ9Hs+uJyASjqykGPr5sP3M/g7b3j41jdm8ycdep1AQCLBkM7qiCeCy9eGCbhe54gnpjtTfH7q9gSYFQs+0lkNaxvhqxFff+cLwPuTPY/Z9OXFVd/vxgQQqbsoT/ZwCsVNQbn5FiKEQKPOUa+GuFlcw83PnJ5tJ9Uyh6672H0Uga7P3s0DrX668A0NrqnBtAPcnLFmfmzAYldyr+PmYiEk6FPINOZpV1idnbgoXPS6OZvTsLI+3UoBw/bkWSzAzVbjZiycKGbPItee9gHsdH29DeCw+w5CiLIQotr69+8BMIhoOejBhBD/SAjxGSHEZzLazSureR5wHI7H37Gx/7R3INqP63LsP7NxeuzAbYVPVSs+Dp7Z2H9qt1Z/e888tQoPfEzPA/af2VP/Xcahvw3Q2WYSvs7ACZ3/mnEDldziB7jA9dN/hRCwm1yWO/WtrKazeqBINQZs7phIJLXQvVnDVmmnPUns2HwgnVsImfAc1sIo8sGb+PD9zMTP5ZkMFFLF4Jq3u7xLcadRbr5lOA7HJ9+xsd83EO3HdaSbz4Lc/MxGpTzo5mqFBz6m5wEHM3bzy294ePvzXxyZrnu+lYSvEzi7dHMjbqCanZ+bZ7mS2+Nm0e/m4EAwTRvHzUOec8qLq7bNewa3gHRzIe/Dbk73yTxDG5ySg3LzXWORK7i/D+BFInoA4ADATwLoqbMkonUAJ0IIQUQ/BDkgv5j7kSoAyJJSd9QMMAHlotwPUoOMp4/FWc/+zXrNQbzEsLljdk685SFlzXZTpkGa5mznYwSAbycf4E/SL+I4sYRf+Zlz0FIUorVfwzc1HDzKIFJzoXscdkSHGxn8E9IdH7rrwzW1uQcavHzFVVzH5th/5sBzRUeWa5sGUmn5WImkLD8ul7r30QJb98yRoSOptI5a1RkYzAoBxGLTfU+rFR7kNQghy/Mi0cHnu2prAtfS4UR0mA2vZ6ZQEFDJqZUqxa1FufkWIYTAwVNnrNXZUpebC0FurjpIJDVsbBuXbi6Fu7nZEHBdDsOYvptffsO7nLQVcttHsmiDuEAtZaGci3Tc7JkaDh5lEa250Bbo5lms5No2l++vd+nmjS0TiVbJcTKloVbhcnICckWXAGztWKPdnNECszWEAKLxabs5vLKgWvHx2tdeBt6bznO5ER1uQMWdIMx10kOxWBY2wBVCeET0NwD87wA0AO8KIf6EiP6b1vd/HcCPAfg5IvIANAD8pJjVxgDFUBybw3WCX3oiwDAJjEnhdd9LCAzM/rZv6y6BGdY/lQiB0ffT5l+ufAbfTezCYzoMlyNVaCJecXD0IAPRDuYgQjMhVyGMpodkvgGuMdST8rblwwoiNReCCCQE6gkTF5uJqffjC+OXfvSn8BPf+NpEPyOEDCXxvPbX8v/HBy4iEQbTkuVN61smsksc9ZpMW0wmx0tCTqQYYiWGevVSpERyAD3tJGVigZVJnefs55V3X7qWVE+3kzLMouYCAvAMhouNBDw1S6y4pSg33y4cW4ROPLfdTCQnivtXz4LcXK34aDa0TsjQKDf7PmBMuXNQz+AWg4FBqXwD8YqNw/uZyz70RGi03GwGufmggki9y81JExcb03fzNAe5QgjsPbY7bfna79/hvoP7j6yOmze2TWSbHI22m1PjJSEnUxrKxd4ASSJgfcuYepIyI/k5HDhLkHzO19/77FSf73QnhdxRFbGqC0BWXF2sKzffJRba3blV2vR7fbf9ete/fxXAr877uJ5HhBColH2UCnIWLZ3RkMqEl67043MEn5wge5zefxTBx382fkiPLBv10KhzaBohmdJQKoSMYkk+xywp63F8nNiFzy7/JJgA4HHES01Us10rckJg6bCKWNWRIykCcieERsxApObKn2u9ULGqA+98dq0K+vnw/Qz+/rsv4V//zB+N/TP1Gh9oDA/IX6FY8LDatT/GirCeVhOOzXF26qJR49B0wtKKjmSq93NFJNtH1Wsc1YoPTSOk0hpMa7wZYs5lGZ3d5DAtNlTeiSTD6fHg7URAMt0rtpff8K4tVaExnG+nQFyAhABn1LlgYh5HotiEafuwIzpqGUulNypuBcrN82PAzVkNqfT4buZchLrZsgi7jyL4+NuTublY8FBvndPbg6AgiORzTJP+wW1QYBATAFyOeNlGLdO1IicElg+riHa5OXtCaMZ0ROp9bq44cM0GysvTd/O0Brm1anA6cpCbIxGGSJebbZvj/MSV11gtN7crstoQEbbu9bk5o41dLdftZstiSAxxczzMzRh08zTg/W7ucq/mSjcbjnRzNWN1qgEUzw8LHeAq5sfxgdvaXyO/bjY4yiUf27ujS0wBIBIiMSJ00vkYI/iBa2fBlEscAJfjAQJSaUK51PvzRMDaevhsou+LribmVxftaWQJrm6A9e0XlYFBHqrZy9viZQexapdwW9KMVZ2BdBYmgGSxObsBrhCwGh6shgdfl7PVr7/3WXwF4w9w269hEK4b/nOOw/H0k8t2FL4vcHzgwnUEllZ6p/SJCPGENnGglOcJPP3ElsfIASIfZycudh9aA2Vxniew99gZWL4lAlY39AFpX3fPcjeCEUTXu280Paw/KwNcgEFeTGXP6iguR1Feig6uGgiB1EUDyWITjMv9Y4WVGHw126xQPNccHbio9rm5UvLH2v4ByEnHsIqV9sCBGAH+BG4uXrpZOp6hUu6dBZXnVSP0GK/i5v7BLRAeCtQO8+se4MZLNqKBbnYD3ZwqNGcywAWA1/5WHb/2tb+Of/7F/xNxr4EHtX0YYrJSNN8XoVdU/pCsJMeWbhb9bnYFlpan5GZX4OnjJnwfHTdrJy7uPYzA6AsF9VyBvSfOwGMQAWsbxkxK3Nv0u9lselh7VgI4etxcWI6iMoab66rX/a1BTVncAZpN3jO4BeQMYKPBe5p+D4MYYW3T6PnbJwJ0g5DNyXmSTEjYwSjarWNqVYHdRyYSSQbDJCSSDDv3LaSzg/Mwniew99TGx3/WxCd/3sTj79io165ex/xbP/ifIqiwVQCw6nJfT5tEsdkzmzyK/kHz1OACa3tlrO6VkTmrI3dcxdbHBRjNyVICoyH7YInkimgYF2fewMqvEO3bp/M7nx678FzREbUQUuwnh4Mj79MjN7BULxYnZLK9Up91W4el4yqoNbgFWi0KAGTOG8ic1Qfvf1hF+qIB3RNgXCBWcbDxpATmzaaNgkKhWDzNBu8Z3ALyHFev87FbqDBGWNsYdLNhEjItd2ZzV3cz5/J4dh8GuDkT4uYnXW7+2EajPtrNQYNbAPB1Ghx0QLo5UnN7zpGJkj2Rm2mWbn5Wxld++Rx/sPL9+FcrP4Df2v3PUDBSEz1MNMYC99sQyRXRMM7PvIGQKCGAi9NputmB56LHzZ4HnB4NDmRPjoL3iMdaKc/zJHdUBeMYcHP2vIH0+WClw/JBpcfN8babA3ovK24WaoB7B6jXQoJ3OFCvjj8oTKV17D60kM5qiCcYVtZ03H9kdfZRZpf0VmJfay/khELlAoAgbN2z8PDFCLbuWYGDLyEE9p/YqFc5IOSJ1XUF9p/KZMhJefvzX4Qd1eFrgzPhBEDzBVb2rtb0RQBoRqe8QalFstCQAUdCHicTcjC9clgJ7BcYhmGwgSRGapWFt1fngwi7ACMCnJD92pNSDQkfk6Vb/Wmfwfet13rv9/Ib3sQ9byeCi4FwizYEIFlogrrkqDt+b0VA634kVD9dheJ5pj6k3V5tAjenMzrudbt5Xbp6am7mADCem/ee2HLivO1mR2DvqQPXDXdz2OAWAJoxA5xRqJtX9yuXt02wDVy0HnsWpPINmE3pZs4BlxmwmYF/tvbKRI9jmkPcnAx3czNscoQQmqUyKdWQThrVSq+bZVJ38H3rQxK/ZwH5AqYdUm4P+b71uzna3nbWdT/V6/52oAa4dwBZIjR4OxGgTdjDzoowrG+a2N61kF3qLR0mImzumLj/yML6poH1rcnkERYO1E+zIQIHUDJyfrLVy85AkAgn91LgAX8RBMBwfOiOPDHWUib4GC+bgCyPKazNpgQqUXIGZqsJcn+J5vgyQGlMVtcNbGybiMUZIhHC8qqOew+soUET/WVIbYTAXHojDjzvmLdPszQ5kFG/OhEM51Kyht3qp9uH6tmnUDzfaBqFulnXJ7s8i3S7ORfu5o1Nc2I3j0uzwQOraAQHiiFuHja4BQAQ4fheKvAcSZA9T9turqasydy8Gh995ysQuJJMDCUjiao2WcL+6rqBjS0T0Vivm2mIm3Uz5HsLcvNNIegz1AMBRtdEjNn0An2u3Hw7UHtw7wDJpIbTIzdwANAfOjANTIt1AoT6E/qA8LAqIiASCT8DCSFARLLUJWQ0PMnKYf8qp29o8AwNWtAMHxE0j8MzNVQzEcQqDqyG19MHNejIj3dScK1Z/ZmF/64E4G+634ufCNmLWyp4OD914XlyoLq8qiOV0Yeu2PaztKKjUXcG3tt4UpuaRJPp4ICTRHKwcX0iyVAtD84IDyuznglEqCdNxCqDe7IBAELA1y9f50n76Vp1V5ZMOT7sqI7Scmy8ZEghEKm5MG0frslk4uic0r0VCsUgiZSGk2M38FQ+i+Ad6Wb571LBb/VVvfx+mJsZA6wx3Ow6InSi2rGDfTXOhKNvavBMLXj1jQDW2l9czUYQrzid1VNxeZcBjndT8Kz57qNkkdHPVyy4uDj1Lt28JsOhJvk8LC3rOAhwcyKlTbyoEUYipaES0EIqmep1s9zjywJ7KbdbHb360VvALKuq2jBCPWEE7skGIDshdE0sueZk/XStWsvNrg87ZqC0FL2CmzU0EoZy8xRQK7h3AKYRtnctuZLL5H+MyR6mesgq3LTY3DFbac3y60iEsHPfRDzBOre1y6a6++K2EVzg9NjBn//bBv78T5t4+kkzdHBLNH5f1bAS3kYyZHVWCDjtvnpEON1J4Ww7iXIuAl+jwJMlZwQ2w84ZtfTgbLUA4OsMnsHw4fuZwFXcYsHFyZHbaQvkugLHhy7KpclmJGNxDetbRqdCoB04tjHF1YHVNQOmRaDW20pM7vte2zAH7ru2IT/PrOe+wFpX0uQkpdvXIb8eh2sMlrxzkgFSfleoRrufbr/+g3r2xco2VvfKiNZcGC5HvOxg40kRekjZVRvyOdaflLByUEHmrI7lwyq2vluE5s6h/5ZCoQhE0wjbu2bHzYwBTGu5ecYrbVv3zFZas/w6EpVujsUH3bwV4GbOBU6Pet08bPI6FtBXdZIshHrcCHEz4LQHqq1KrLOtJEpD3CwYzW7/LYBqiJtrYPhL3wp3UDHv4vTI63VzKyB0EuIJDWubdknLBAAAIABJREFUfW5Oa1jfnKKb1w3ZgqrLt4ZJWA1w8/qmCV1H730Nwur6bCoJhpHfSIS7OWGCdw9wW/10g9xc6XdzqYnV/TKi9ZabSzY2npQ61QVhkM+x0ePmCja/W+zJfVFcDbWCe0eIxhgefTrS6lMrEI0OroDNAsYI65sm1jbk6aT9nFv3GBp13mlFkEpr0AJ6oh4duD0NwpsNgaN9Z6BBPSAvDMYJLBg2yKlkI0gUbcDnnRlgQUBhNXbZC1f+ImjGTTTjJjRPDjT6j56EAHGORKEJX6epr5iVs1FEKy5MW64kC5LHdbaV7DxPUKLy+akX2Nj9/NSbeEU/lZarvq4j5IBSp6l+rjSdcP+RhVqVw7Y5TJMFrt4C8rkfvmChWpH3tazWfVvv29xmiSFbFBw9zCBZaCB93pRBYwTUUhYKa4NlcafbSSwd1zqtp1xTw8VGvHf2VwjkTmoD+4HAgcxZDefbKZhND5mzOoyGC1/X4FoMTtSA0fRgOH7nZ0kA5HEsHdVwem+y4BOFQjE9YjGt5WaZlTFXN2+ZWNvsdfP27qWbdZ2QDHPzvtPTxqbZEDg6dBGNMzT63KxpGAikevWjtybKQqgsRZEo24AvetycX4tf9sKVvwiaCRPNhAnN5YgHVdIIAfJFy81s6itmlVwUsaoDw/Y7bhZEON9MhrYQEkKEu/nEnai6CpCvdyo9OzfrOuHBC5dutkyGeJibDcLDFyOoVHw4toAVCff4rOm4Od9A+qLXzfkAN5/spLB01HIzANfScLEe701RFgK503qAmwXSZ3VcbCVhNlpubrbdrMGJ6jCbHnTbvwy9ark5d1TF2Y5y83UYejVLRCkAK0KI7/bd/pIQYvw+JIobAREhGltM2UP/iYyIEItriMXDT9quK3oGt22EADQdWF7VUcz74FwgkdSwvGoEiribUSt4XGM4epBGotCUPWx1hkouCntIGEV5KSrLUbuOk0Ou4K4cVFu/sBTc8W56eo3GGeFkN4VIzYXVlG2CaklzoJ/b25//Ir7yT/8hACnRsPYCVwmf4Fzg5MhFpSTfJ8OQaduTthwYBhEhkdSQGBKq0bkvkxdkSQzed6bBUoEHQ6jkYqhko2BcgBP1Xoh1ITSG860k0OrZF9STT/NE4KoDAYg0PJgNF2vPylKQkAEZpuMjVnE7SZEDP1d3kTmuwfB8NGMGqukIxIi/IcXiUW5+vpBuXkzbkSu52eGBPVoFBwwDiLfdLC7dzLrOK6+8+9LE52Pp5gyShSaik7i5Guzm1YPLcCrOCCdTdLNg0vW9brY659Zf+OYRfqL/ZwTghyz2Be1rHgX3W25upXQbJmF90xj6vk7KpG6exZa4K0GEylIMldyYbt4e5WYe7ua6C6vuYnUvyM1OqJujNReZkyoMl6MRM1DLRHoXWRQjCa3nJKIfB/BtAO8R0Z8Q0Q92ffs3Zn1gisUihIDniYGk2nniOjx0UtWxBXLLBh5+KoIXvieK9a3R5dbjlqdyjaG8HMPx/QzOt1NDBQrIEtPTnRQcU5a9cAKciAbG5UyzTDeW+4RWuqQ6FVqz1aXlGKqZyMhm5UQELcQxTMPELQQO95zO4BaQIj545qDZ7C2v8TwB31vcZynywZvj31kIRKoO4sUmDHsKQRJEssn8OHJiFPoe8pByO0CWpWdbM8jd9yHIk/ywZ04Vm4hVXWTO6th4XFTtD244ys13m5vgZscRQ9yMSzd/OtoqT+298+vvffZKz8s1htIkbo7oONtOwR3mZiHTmJdn7ubL1+DD9zP4+jtf6L87tJBxImOTu/lgz+lpD+k6stOEfcPcPBE31c1sRm4u2IhVXWSVm6/EsOmUtwH8gBDiiIh+CMBvEtHbQojfweicUMUtRQiB/LmH/LkslSGSYULZJX3u5SSGyQL38wAyzXkSZr330o4ZOHqYBXEBQZB90gISjnXHh+b6c28S/mpXSdTyqiFDx/qOj/vAs8c2dh9aY73XrsMHysQBOROdP/ewuW2i2eA4OnDgOrJhfTRC2Ng2YZjz2/4f+eBNfOmr62PdV3N9rD8tg3He2efdiJs430osPPRBMEKtFV7V/dniBJSWolg6qg7/efSeuPu/ZgKAx5E6b6AYUKqluDEoN99BhBC4OPOQv/CAlpuXV3Vkl+a/j9E0KdTNw4IigfnlILRpxg0cdrl583Ex0M3GnN384fsZ4J0v4Cf+2tfkMZAMezw9HixT9id0s+PwgQAxoNVp4sLD+lbLzfsOXFd0SuM3ts3Q7gizZJzVfN3xsfas1AkUA4B6wsTF5g1ws8ZC3VyeppsvGijOKPn7eWTYVaYmhDgCACHEvwHwOoC/TUQ/j/G6uShuIYULDxdnHji/bPJ+fuqhVJx/JLphUKd3XzfEgNzy+KUu8xSqYDLRYVg/vqDE3DCYz6G5PDi5YwJe+3IDL78h38NMVkduJVjiji3GDrRw3fBZfNfm8DzZE9GxhTx8ATQaAs+e2HNdfRh3cAsAKwcVaB6XK+6t2f1ozUGicDN63uXXE2gkTAiSs8btwW09acIfo60I7/t/PwxArOJM63AVs0G5+Q7SmXjucvPZiYdSYQFu7uy37L2dmOy5G8ZElTRTpu3moX8hk7jZa7n5GvSv5GZyBnLL4W4O6yfbjztkhd22xaWbnS431zmePZ6vmwF0rktGsXxQgeb1rrzHqs6N6UebX0+gETd63FxcjqGessZzc+v9CnWzUG6elGGveoWIHrW/aAn1NQA/AuAvzPi4FAtACIGL8+CQg4uzxaStbmwbyC5pnWTcaJRw774Fc8wVwHnPFrcJ68fHNZlwPArN9bH2tITtjwvY/KSAzU+KMBvutY7pl370pzr/1vXBixNAvtfjNl83rfAV9kiMoVwc/CwBcjY6qGXALJjk/dc8LkNB+m5nAkhfNBCtOteeaLgughHOt5LYf5TF8b0U9l/MobwcA4hQWooO7QHJNcLFRhylXASFlVjoWp/ag3vjUW6+Y7Qrq4LdvJh+nJtbJrK5LjfHGO49sIZW50wy2TgraiFu9nXWk24fRsfN3227uQDzGj1R+we5w9xcq453HWZFwt0cjRFKhWA3c1+gXrt5ZbCa68NwQtx83kDkprh5O9Xj5sqS7Hlczo3h5nXp5uJqNLRfL1d7cCdi2DLYzwFgRPTvCiH+FACEEBUi+mEAPzmXo1PMBd8XqJR8eD4HDzl/elcIOZgGRISVNRMra5P93KIGtm0qORk81U6ubZ/czsYpdRUCa8/K0F3eCSBgLsfaszIOH2XHmg0M4sP3M51gC5moGOyEcVtH6TohndVQKvQGgTEG5Jb0wMkSADIleEGfp2EMaxvR3qPl6wzHu+meVgKLgOts4BhqaQvMF8ic13uqBETns5eEHTNQb90er7Z6OXc/LgGVjDXTY1dcG+XmO4LvyYoaz+fgIeMOb0H7J4kRVtZNrIw5Zl20k9uUWwnHerebCTjfTI7l5vWnZRkqhJabHY61vRIOHmav7IXucmUtxM1EGLt8WNcJqYzsId/v5uySgYvTwS1KrV/vSmGTs2ZY1ZvWyjbxDIaT3bTcU7tAgtxczVggnyNz3ugtRW59iAbcXHZhNgPc3NeaSDGc0AGuEOJDACCiPyai3wTwdwFEWv//DIDfnMsRKmYC5wLcB2zbx8GebDQ/bALMsm7PzNFNEKlghOP7aUSrDiJ1D55OqKUjYwkwUnc7Au0nXmzKFbsr8vWWRLv7EHdDBKQz4+9BWl03YJqE/IUP7gtE4wyrawYMkyEWYyiXfIiAC7NIVL4OQgiUij6KebmvLJXRkMpo8FyZlG2MMaMexqSfA89g4BoDC+g/R2jF97scuZOaTDy+aRChshRFJReB1iqfizQ8cI0C07XPN5NY3StB7yqzq6UsVDNKojcZ5ebnm7abm00fh3uyameYm81b4Oavv/MF4P1FH4VEaISj+2nEKnKCz9OZ7Ck/jptrLpgf4GYBJEpNlJeu7uYP38/g77/7Er750x+GjrP7Wy0NY21DurmQl26OxRlW1gwYBiHadnPA56rbzcWCh1LBn7qbu/n2L/448NXh9xnHzYbDkT2p4WLzhrp5WaY2az6H7nJYDQ++RqgHuPlsK4G1vbIsgScAQk5g19Jq8nkSxvlr+YsAfgXANwEkAfwWgH9/lgelmB2CC5wcuygX5VLtOFUdRMDKAhpyX4WbMLjtQIRG0kIjOdlJKWxfD2udxK/Dh+9n8Hfe8PCtb+i498DCwTMZMoFWSv6oACgh5D6gUkHu005lNGSywUEniZQG/cyTj9/6nBHJUrZoS6JH+w6qlcswjLMTD2cnXkfw0RjD5o45sv1TP6+8+xLw3kQ/AhDhfDOB1b0yAAwEkQDSNbFKqxxqwcEWoRDBNzT4hgZnSMqob8i2G2bTg+5y2BEd/rRaWCnmgXLzcwTnAqdHLsqlydy8esPd/Mq7L+Ht9zKLPoxeiFBPWainJnOzPsTNYd+bhNff+yy+wv4IO/ctHOw5snKu5ebNneGdItpuLuZl5VQ6oyG7pCO3PPj5SKY1XLTd3IIIiMVZZ4B7uNfb53habu5nrLL1bjeL4L2VbTdfXOtoZgwj+Ey6eVgCuG9oOHyQgdXwoHkcdlSfezDp88A4A1wXQANAFHKW+LEQQWsyitvAcVfP0mG099WYFmFlbbq902bFjRrcXgMnEvxnyQloxsabwY3UXKQuGtBa/U3LS9HOCfLbv/jjwDd+B7pOyK1ocF05axuPj268fnrs9pQkNxsc5aKHnfuD6Y6MEXYfWrg4k585ECGT1TohJM0G7xncdtO+rV7jONxzsHN//AuRl9/wrtyGwo7JxM14qTlQTvRcQgQnasCJLvpAFFdAufk54uTQ7WnrEkbbzZZFWL4Fbr7qufgmYkfD3WxHx5toiNQcpC6aLTebKC9He7Ydvf35L+K/f/8fYGlZg+cB1phuPjlye0qSmw2OUsnHzq453M1lH0Ryu1Guy81BfY6BLjfXZQrz9u58VhWlmzOIF5vIXDQD3TxJgOeNh2hkGyzFcMa5Wv59AL8L4AcBLAF4h4h+TAjxYzM9MsXUae+1HWdmOBpjcztxTYPnZXALAK6lwY7qsBpeZxWRQ4ZgjDPjnCg0kT2tdX7WcGzEyw6OHqThGxq+9NV1/O2qj4NnTqf8BZDtoJZWwk+ojsMH9tsKATSbcuY4mRq80NI0OUGysmYMSLZRH+9avFHn8Fwx9t7gX/rRn7pWOZxvyD7IZtNHrOoMxPc3EsbNXb1V3CWUm58TfF+MNbgFgGicYfve7XBz5IM3R5af3iZcS4MT0WE2B91cS5ojfz5RaHR6ogKA4TQRr9g4epDpDHI3P3mMf/tdD6bvXbp5VcdSwEpsG9vmA/tthQCadTlQTSQD3KwTVtYNrKwPurle56MDpYWcgPY8MdDneFwmrbTyDQ3llTgs20e06g64uZ5QA0LFJeMMcP8rIcQftP59DOBHiOivzvCYFDNi3GbeRLL09LbwPA1uk/kGMucNoBV4xJlMzqsnLZSWo7LVwTC4QPas1lNeSwAYF0hdNFBYT0B3XDw+FDBa7QHaXJx5iMU1RGPBJcph6YqCy3TH/gGu78uSu/aFWyzOsLZpdBKwdZ16BtihEOD54w1wv/7OF2RgxxQorMdhPfHAfN4JI+GMkFc9YhU3A+Xm5wTPE2OdC2VGwvj7MBfJJP3HbwPJiwYyF/VOHxefAYLJgW1pOSrriIfBRc/gFmi52W+5eS0O3Xbw2u/+bzBcr+ejcHHqIR7XOuXD/TTC3NxKXu4f4Pq+wMmRi2rbzQmG9Q2jsz1J18dTM0heV151gPs33e+90s/l1+JYb8qeuB03a4TCWuJKj6d4Phl5puwSaPdtKsTiFqIb4cm5bYiAeIIFrsYFIYSA6wpoGl17L8ZVmNngVggk8w0kizYYF6gnTBRXYjNNz42VbWTOegXIBVBPmiiMOagy3OAYbAIQrbkoANh88gQiYAVSCKBU9BCNBc9Ea9qQ5OW+914I2WfPbnY1Za9xPP6ODaYB2Zwu2z8RMKrxAQEwzfE+W9Ma3AJyVv7gYQbxigPD9uBaugyEUFH9ihuAcvPzg2GM6M8K6eZEUkMiOZ6DFunmV959Ca/PanArBFItNxMXqCdNFJdn6+Z4sYnM+aCbq0kTxXHd7PiBo0aCLFsG4tj+5JNQN5eLHiLRYDczDaEj0v73XgiBvcc2bLvLzVWOT75jQ9OATMvNxAAxQs6E64WcXdXXvqHh8GFWdqpQblaEcDumAhVTgTHC0oqO89Pe9i1Esjk7kZzJi0ZH7/cA5An35NjtpOTGEwwbWybYnGQ6y5Xb5YMqojWnI7REyUa05uDwQWYg8S4IzfURL9lgvkAzYaAZG13Wmj5vDAQbMQEkijYKK/HRM8QAfI2F7kNpl0Bpnhc6yzFs8iOeYIG9U4mAVLZ3QqRR53Ds4AfjPpA/lwEXPWEaAc9PBKys6WBj/O6vfvQW8OXGyPtNBCPUUiaiNYJVc5Hw+NiJmwqFQjEObTdfnIW7OZ6QAUDjuLlU9HDa5eZEUsP6ljHWeXQazHLf7cpBRaYZt91ctBGtujh8mBlrgKM5PuLltptNmWsxys35YDcni00UV2NjbVnhWvgkhq9LfzLfD5XwkC52SCQ1ENyBhw/qitCoczghbfr8lps9T+DefRlC2W5DFeTm1YDy5nG5UhBkF6Lt5irBqrtI+Fz2OFZuVrRQA9w7Rm7ZgGEwnJ+58D2BSFRGx1uRyU4K9ZqP48PeXmq1KsfhnEIHZjm41W2/Z3ALXJYSJUo2KrnhiTzRso3lo2pnoJksNtGMGzjbGt5nTwuIwG/DuBiryTfXGZoxA1bN7Uka5ASUWk3HD+/vggU0VSQCUkNW7hkj7OxaOHhm9/RkXN8yO2XHbcIGt22EAColHytrBh68YMF1BISQASqFvIdalcMwCLllfawQlZff8PDatAe3AMAF1vbKnT1XnIDMeR2nO6nrBUBwgXjZRqzqwNcYKtkI3JBwMYVC8fyztGLAMAkXZ9613XzS5+ZqxcfRvsDWHPbuztLNhu31DG6Btps54qUmqtnhbo6VbSz1ubkRN3E+oj+9FrK9i4Tsny7GmNT3jVa2Rt0bcHN5SbZmO3xwP9DNmoGhVXWMEXbuW9h/Zve05QvqimDbYmi1gFwt9rGyauDBi31uvvBQq03m5jCuOwlCXGD1WQmmfdnPOHNWx8m9FJwxA78C6XazzlDJKDffVtS7dgdJpjUk05OfmByHw3UELIshf+4NzOiJdujABIFAV2HWe27NphdY7sMEYDVcVBAuUeICy0fVXgELmWocqzhDQ6KciI5I3R1YJBWM5OzvmPz/7L1pjGTZdef3v29fYs29srJ6q25LlqhWm9LQ001KYkOypG4Co3HbkkZtQAN7ANqgxw2BBCSKA38dD4QeAxYwnmnCaMD+MKOW3SOox6K2GbcsA95Ijdii2KIskuqqyqVyiz3i7e/6w42IjOW92DIyIjLz/IBCVcb2bkRkvd879557zuluBpuHDeitoPs+ypsW3IxIb/IsC//vj7+MT/xvfwQpiiBx3k1/szKjL6YMU8Iz/44B1+HgXFyEJa0KaMb4/bWMAb4Xw7LlvjSnrZ3xxToGeVV6Y+rnTEK24vYVFOn8vXFYx8H94mzFpmKOnQdVqL4QMwdg1zyUtm00R/SgVfwIdsWFHHG4topWVqNiVwRxg8jlFeTy01+W+V6MIBBuHlwFBjp7MS9XEGgV0NzknFnh5hCNYvpzWcyxnuBms+nDbPgj2/l5hgyzFQ7dHslsqrTYs7tZbBw0oDs9bt6y4NrCea5t42uf/lH88P/+f3RXcyNVxXeeexb/0St/hQ9+L/26zTAl3O9xs2lKYAlj0/UJ3exzmJbU7+Y707s5iXlkW2XKTje4BS7cvHnQwMH9wkxuZG03K71urnoo7dho5idzs5NR4WTIzasABbjEWOKY4+CRD6cZd/dgpv3fZUwUzLiqAHcRBaUiVUo8+ccAgp5eZIoXijRkDrQyGjxL6Qsqe5G4OFGOCnDLWxZ2HlQBfpEJHDOgtGVBCWJIEYevy2NTlbks4eReDnIQQ4pihJo8JOG/euEHcXJvD8/8+Ye4c7eOf+9PvgNrglYEAMAYg2mlPy6OOQKPj91fyzmGVn5n4UpSk9t0vt9BpIhD9SME+vSn0EzV7Qa3wEWj+rXjJlo5PfGCqTcrgEEExNmyguMnciRSgrilxFHbza0LN6f1Nuu6+QoD3Kv2c6gm+yJmQNDTw1v1QlgdN2c1eKaYPE4qItFx86gAt7JpQ39Y7Z5/O8csb9tTuTmWJZw8kYMcRJAiLsY88Jy//KGP4/jJJ/DMNz+EEgR4+NxzePzEPXyGvYqvvPLr+PrvpjtnIjf7k7lZnbDuxSzMI9sqU/VT3BxD8WOE+vSLOJmK2w1ugR43P26ilU12c29WQMfNvkFuXgUowCXGcnwUwGmKnmgdN6Tt1RRBy/UNbgHR6y5UZah+1H+twIBGUczidVrxdFKdMhUXrYyGZj5dknzMxxIYCh4/mUfhrAXNDRGqMuoFHbmSC9Vvds1a2hq90tchUiURrKdQXV/Hn/7Yj+BPAfzy/2Li//yBfzz2NccR+DEe/LWHOH0rEYCLgimXnQh58e3nryY1ucOI4fEZu+RatWQxg4lVCNceSK+KOTYe9688SFxkGmQq49PyCIK4mRwfBXBa/W5OW5m7SjcDi/GzcLME1Y+Hzr6dFbZOK54+N2c1NHMakj4cDowNRHyz7ebTFjTvws35cwdKp3gUgPNtG60RK30dIlVGNCKLtrKxgX/7Yz86dPur0htjg9zU9+DHePhdDzEHRnXLZkykQ1/VRMjcWkeNGt6MQ7fqaW5m0NxwaFtSUlZAx8121ZvoOo24Omg3NjESzifvncuY6KV6FUWmFtoKiDEcP5GDa6vgEIFpoEk4fiKHSJUhRXG3zyxDew8QB6yGD4AnBj4xAxoTnOwCQ8HpXg4Hz67h+Ikc8uduNw1HisWfteMmNGc4XeoyzCtIfHwYIEqoYWVnJJEaBfF7UliTceduuuE5F2lW47jKYiYA0MjriAe+Tg5RsCucZfWZi5XfxHfGkbjPWndDJBlb4oBd86cfA0EQ1544nrx3btfNV1Rk6sW3n7+S1x2CMRw/kYdrXbjZ77pZghTG3VY8fW6u+7i4pR/OgEZh/N7kwFBweq/XzQ7UATevP26KLU5XyKvSG3jhlemP8fggQBQNB7d2dtjNO3Nwcxrzah1VT3OzKqWu9I+EczFZkXJfopudMDGYFm72ph8DMVdoBZcYSd/M8ACdmb5WM4KsMKxvqDPt7R3HMvrcxopI82VRDMbRV5nPaAaJz5E4YNcDnO5lsbVf65ssbuT14ZW5MaheBCWIhs6fjAPZsoNzMzvV6101POapvXKdVozn/l2zK8a0VOhOf756LQI4YJgMO7taYqGVd956HXhvfuNPolEwYDRDmE1ffJ8M4IyNLRiWRqbiQoqGp0A4RAVs3xj+/8MZ0itrUlsEgriVjHSzJDJknI6bN9WJW/9Ny4tvP3/lE429xIpI801ys9lM3iLE2hPQJ3fbbu6hXjBEl4Mp0NwISjC8isw4kC25ON+92n6s3/rlnwN+919O/Pg45nBaI9z8vRO6+bDtZgCmJfra6/rkweQ8r+UaRQNmKxDXYx03S5dwc1m4eZDOhHaQkPI8KiuP3Lx8KMAlRiJJDJrOEqviWraEO3vzKTqQxjKC2164LA2ttvHORPBgIQ+IlVrPUrF/fw1WwweLOVxLnWk/iBzFoifewFUMA6AEI3KMZuRLn/kc/uHv/Pdzf91eRu3x5Zxj/yMPbk+VR9fhePjXHp5+zhhKmZpnz9tUGMPZXhaaG0JvBYgUCU5m9n572YqXmjZzfsdOFLNvKIhlBhb2B8aTZgUQBHHzkCSxTzLwh91s2xJ2r9jNHX4p+NhCjjNIqpvTHs8YPFvF/rM9brZVhNr0bpaiOHE/LwMgh+M6u1+ez7+5gz/6xhfmsq2owzg3D/a1d1oi5fmZ5wzIE6Qzz/1ajjGc7uWgOSF054rdvJNcZdszlXbf4v7fA3LzarDUFGXG2E8zxv6SMfZtxtgXE+5njLFfb9//Z4yxjy9jnLed7V116P+2JIkeaFfJsoPbNFxbS9znxBm6e3C5zNDM62gUjcTglsUc2XMHWw+qWD+oQ3OGV4V9QwFLmKKPGdDKXM1n/85br8/8XCax1CrMk6zsuy5PbGHAOVAt96dkvfSNL8w8zlnwDQX1NTO1CNSkJH2fQGeWOOUzYgwneznEMkPM0P3TKOhwruj3gLjdkJtXH8YYdlLcvLm9mPPCO2+9vpiJxglxRri5keTmhOCWRTGy5y3h5sN0Nyctn8cMooLuAvj0F52JPShJDJad4GYG5CZxsxPDT5hI4RyoVManS1/ltZxvLsDNaSnPjOHkXg6RxBBLF36uF4ypM/aI+bO0AJcxJgP4JwBeAfB9AH6BMfZ9Aw97BcBz7T+fBfBPFzpIAgBgWTKeuq8jX5RhWhKK6zKeetaANkVqyrSsanALtNNg9rJ9wUanz+wk/ddYxHHnrysonLVgOiHsuo/thzXYFXfgQO02BD03xRDpMlc1O/jBe4VLBY/bd4YvuAAgM6b9EAAEXpy4n4VzEfx2uLKetwugmRveNwSINLtRe3oDQ8H+s0Wc7WZR2rZx9HQB5e3RvRsJYhbIzdcHy5bx5H0d+cKFm5++Yjf3skrBLSCC19O7w26ubJgT9TJlUYw7H1VROHOEm2spbgYQp7l5giJT82KaIDdpoQJc1McYh5/SO5dzwHeTA8MOq3wt10szq6W7ecSeXr/j5jsZlLZtHD5dQGU7ORuLWCzLTFH+BIBvc86/CwCMsd8A8DMAPux5zM8A+J+42BzwfzPGCoyxO5zzo8UP93aj6RJ2dhdmxW78AAAgAElEQVQzM3kdToiurWH/2TWYDR8S53BsFZE6WapTtuJADuOxbWK29utQBtJSGYDStgUuX90FzKe/6OAfzvhcz+WJ+8KODgI8m5VHpkFpRnJ7JsYA0xTPe+GV8Mp63i6CWtGEVfOhBO3m9ADAgLPdCYJVxuBkF/N/kLjVkJuvEbouYefu4s8Lq+ppN6Nh/9kirEYANq2by26qm5s5vdvSZ2u/BjnBzefbNvgVFNkcxae/6EyUruw5yW5+fBDg/veMdnNSDQxAKEs3k5/30je+cK0momvrJqxGcOHm9tuayM0SuXkVWWaK8l0Aj3p+3m/fNu1jiCngnKNRj/D40MfJYx+eN/+9nJdhVaWZBJcZWnkdjYIxsUABwKwHI0vRA6JxuOqFidXus5Wrr843a6pydUS6UlqRiw6GIcG0pMSUu3xRzMX96t/+xeEncg6z7mPjoI71w4boRbyicJnh6Kk8zncyqOd1VDdMHD5TGGo/QBBLhNy8BHrdfPrYh79ibu5lliq+i4TLkkhDntLN6W1iAM1ru9mLoHrDxR8BIFsdXuldBJOs5Ka5mXPAcca42ZRgmCluLgyvk73z1usiuOUcZt3DxkEda0er7mYJR0/lUeq4ed3E4TNFcvM1ZpkruEnnh8FTyySPEQ9k7LMQqVLYVqkvZBKccxw89NFqxd1S8ZVShO07ajeAWCbXKbi9DHHaDC/n3fvkcEQRiysoMDXIB7+dx8d+5T/Gn/xGAFfWsOFV8NL5n2LHPRv9xBHZSpN0Frj7hIaz4wDVimh/YWckbO2okGUG4/3X8MGbAylxnGPzoA6jKSYNOACr7qG2ZqK6aY0/4DKQxMRIa0TPZIJYIuTmBcM5x/4Dv9vTFgDKpQjbu2piALFMrnsWzShiRQK8hCJRHIglsR4kR3FypWYsxs3gHLlzB7l21V/fkFHatvHpL2LkSu5I/07g5r0n093c4cW3n8cvBR8TqeucY3O/DqN14Wa75qG6bqK2sbpubub1bi0V4nqzzDPnPoB7PT/vATic4TEAAM75lwF8GQC+1yzM3qTrBtOoxWg1474THeeiWXwmJ/edqBbNbQluAaC+ZnRP+h04gFCVELSLXvj6iCIWCyheUDht4Y/flSG1Cx+dGmv4nTs/hp85+DfY8Cupz8sV5KHfsQ6mNT5hRJIYtu5o2LozfF9S/zyjGXSDW+AipSxXctAo6FPN3i8DFnHkz1uwa363EEptzeymwhHEEiA3L5h6NeoLboG2mw8DZHPylfWvnZabHNwCQK1oQE9ysyZ3i0X6upwYEC6qwFThpCkq/rbHoLsRth/W8PjJ/Mh05XxBHvod62Cal3MzABjvv4aXexxtNoO+65yOm/PnDpp5I71w04rAohj5c4fcfI1Z5m/YVwE8xxh7mjGmAfg7GO5q+R6AX2xXbPybAKq0x2d2atUw8eTG2Pj00avkugS3chgL+YWX+6xcW0Nlw0LMIKrvMSDQRN/dTg4Ql1n3MR1iiN5q9bX+VRApjCEH0WRLpBPAYo5s2R1K1QqZhD8pfv/I52ZzMuzMRSoTY+LPnT3tUhdpab8jZsMHS3nbZkq/4lVA9UIYdQ87DyrIll0oYQw1EELdflSb23dJEDNAbl4wtWqU6ua03uLLwPq1X1n2EBKRgzm5OaOhum4Ou3nvouc8lyVU2o/pEENkZjWK/QWm5u7mKO4Lbru3twNHID1dOZuXYSW4efeeBnZJN3/pM58bmoA209K9ARgrnKrcdfNH1SE3b+2Tm68TS1vB5ZyHjLG/D+D3AcgA3uacf5Mx9l+07/9nAL4C4FUA3wbQAvCfLmu8N4G0kxjH8gq+XYvglnNsHDZgNnyAMTDO0cjrKF2iUl593USjoEN3Q8SyJGaFB16rvm4i0GXkSqLwhZNRUVszu43t5TDGxkEduhuKHryyhLM7Njz7crPIShAlpmCBSTjXR1fNZIxh954GpxWj2YggyxJyeRmKOvsvmPH+a8CbyfelNlNnq9loXYpibD2qQ23v52K8P9dT4hA9d52Q9v4QS4HcvHhGBRjSiix0rWTRoJhj46gOqxF0e8Y3L+nm2oaFRtGA5oaIZAlBkps3LISGgmzJgRzyCze3iz/KQYSNw8YVuDl961KnfgeQXHiKMYa7vW5W2m6eoIftIC++/Tz+9OlnE7OqOsSSqDI99OoMiFfkd7oX4eYa1HaKepKbdSeE5oYTdcsgls9SN3dwzr8CIcre2/5Zz785gP9y0eO6qRSKMhq14ZliBsCaIH103lyL4BYiJUhUS0ZXLHbVQ6hIl9pLwmVJ9NQdgZvR4A6mPXEOo+lj47AJKRaVHBnEbPH2ozrOt200i7O3KgiV5GrG4DHW/OrY5zPGYNkyLHs+6cGjJNrMG8iV3cRV3EX1I5yG9cMGNDe5eFgH1g5yKcAllgW5ebEUijKa9QQ3s8m2diyClQtuARRPmjAbgQhGetwcqDLq67Pv944ncLOT0YYdwzmMho+Nowak9lbdPjfv2GheosVfqEqJK4gc7dTpHtKC3Mu6+Z23XseX3h3fHqpZ0JGtJLmZjf1sl8HGQQOam1w8rEs7yKUA93qwWtULiCvFsmUU1xWUz9szfUycfPeevFyKSgenFaF0FiIMOKyMhOK6mjo7eF2CW3CemBIkcSBXdhdfLIFzbB40YDT8rjx7YQDWj5sIDHnmkzCXJTQKOjID71uVYny8/GH6E2ekpObw1bUfwLGxASty8PHyh3imuQ9g/O9JqIsCG2vHTXDW+TwYTvayl2r6Pg/kMIZdFYVAXEuFZ8gwW8FogQLgkuinSBDE7cDOyCiuySiX2gWO2ueyu0/oI9u3TEqrFaHcdbO4Dphm5W4lfc05MtU0NzuXCnBnHc/mQR1GI0h38+MmAl2Bb8526d2pDm0PvG/OgGrCtcinv+gAn/kcvhL/Or7+u9Mf81zL46trP4BSbg1nSgbVDQvOe5MFp4GuoLxlo3hy4WYOhtNVcHMQw6613Wyr8HUZhjPezWBAuOJ1PYgLKMC9ZWxuqygURSEgSWKws9JcClhUKyGOD4Pu5KLnRaiWIzx13xhKT11JWY4gbY+nFC9+L4bZCGA0/bGb5/PnDk73Zp9lLG/ZiCVJ7MWNOQJNxvF2Dj/53MlMokw9jprFb+39BEImA0yCoxh4f+vfR/PcxL/4kf9gotdoFgy0shqMlkhTcy116YUgjKaPzf06APH7ky278A0FnCekbPXAAXDG0Epafe6duacm8gRxo9jc0VBYE4UgJZnBzszJzeUQx0e9bg5RrYTCzRMEuS++/Tzw7qWHMXfEqm3yfVK0eDdbdV8UPBzzuNx5C2d7uZmPU9q2EcmSyFxqu7m0YyMw0r38qvQG/tv3H8N9+V9Ofhwtj99+9qcQeAAiBj2KsHFYR3nLQqM42eRBo2igldOgr5KbGz42D/rd7E3o5lhmcDIJ11Xk5pWEAtxbiKpJyGvzWyHinOOkR6DiNiCKgPOzANt3Li7Wr1twC8YQaDI0v791AAfgjhDKVWHXhmesB2EQfXRHwjnsmo9MRfTta3RK4/dUoKhuWqLVDufd21/FG/jKK7PNBifxtbWPIWoHtx1CScG/feKH+o47Di5LcLIrUtqfc2wcNPq+p07aMZcYMDAx0tmn1Ln1fMceugjIlF0UzlqQIo5IZqhsWpdKdSMIYvWYt5vjmOPkcYKbQ6B0FmBrZ/xq3Mvvfmpu45knXGIINAma319YigPwlpBCak3oZnVcKyHOYdc8ZNr97hsFHc3ceDeP4/Nv7gCf+Rx+8G9V8PP/+T9PfdyLbz+Pl9/9FDb3ayL9u+c+iQOFUweNgjHxceMVc/Pm4bCbdTcET6g7MuTm7Uz/++YcmYqLwplDbl5BKMAlLo3v8dQ2as3Gxcn82gW3bUo7NrYe1bpFB8QqG1Dethc+Fs6QXLih9zEYL/hO0azOiV5zQ1h1H6d72WFxDfz8rV/+OeB3J58JHsWxvg7Ohi/oWi6HEsQIteuXDiT22A7/j5A44KsMLOB9BSwG/86V3L4LArvionjS7H5XSsSxdtwEABIpQRCp+F56xNXr5jRW3dml7Qy29gfcLAHlrcX3WeVpRZV6HwPAHZWePNDXHehx893xbp6ED94r4INR32t7tV5zkmtFMM4hBzGia+hm3QkTb5c44OkymB+luplDpL672YtJoUzFRfGkNeRmzoBWnty8bGijF3FpZJmlNgqX2ylQqy7KUXiWisdP5dHMafB0GY28jqOnCyNTgq6KRsEQM40pdARfG7H/SHPCvuAWECd4oxWkCqCXz7+5Iyobz4Fs2Eq8nQGIltiXeSY4h+qFolVFyv+HSJHw+Kk8GnktdVJo8DsonDmJ+8wKZ6tX9IUgiNVBTm6nLu4bc36d1zn+KvFsFY+f7HFzQcfRU8txczM/iZuZ6KWagu6EfcEt0HZzczI3z5NRPeTj61YjouPmiCNNznHHzblkNzMABrn5WkEruMSlUVQG05TQGuilyxiwtq5c6+C2Q6ArON/Njn/gFeNZoh1BrtR/Ao0lBsYBz1JQ3rRGrnwarSBx7xLjYu/oJNV7O+lOsxav6PDx8of4A/2TCKWL14gZ0Mrq4PLqS1SKYthVD2bd77sASbrOiZmYoAh0BaWdDOxaKfF76GtvxDnklN6OabcTBEEAgKpKMEwGpzXQVoYBaxvp5+0XXgnx6ojq9atEYKyGm11bRb1oIFsW2346y34dN7uWgsqmPXLlUx/hZr0VLLSyfnXDxMZBvS+AixnQzOtLLxI1CVIUw654MBsTujmvCzffycCuT+bmtL3eyrg0dGIhUIBLzIXdexr2H3rwXN5t07a2qeC/+YX/atlDu3FUNy00CjrMZoBYYnAy2lTCiWQmqhoO7jdh08/Mvipdbk/uPecxPnX6NXztqR9GzRWv0cy1+xiuKJoTIldqQXUjKO0gc3AWtzNP3N3Xw4BWVkOrk97EWPdiaPACot7b4okxhKqUuG8rVFd/AoAgiOWye0/HwYCb1zcVZLLpgdar0hsLHOHNobJlo1EwYLRmc3MsS+luXvCEr5PRUNq2UTxpdVswdXsMryiaEyB37kD12m7mw2mqfW5u08zpfW5O6iIRM6A24OZIkbrXAL0Ec9xHT8wOBbjEXJAVhiefMeB7McKQQzck/Nd/i9okXhWRKqNRmG0PTCurYe2kmZip05yhGMRlg9yv/+NP4pu/nYccxkLwKzQ7rPgR8qctmK0AkSzBtRRkKl63DUTanisGIIaYBe9UjxxMm6tsWlCCGGbDB2cMEudoZTVUN8yhx60fNYZkW95c/D4zgiCuF0qCm0elJxvvvwa8ucAB3jBCTUZjxv2prZyG4kkz9b5F0ywYaOb1lXVz4bQFY0Y3VzYsgImV90Dvd3N504Yc8j43N3P60Nav8qaJ9cfNITdXNld3EuA2QQEuMVc0XYKmX+89t3OHixOlHHJ4prKU/UF9w5ElHN/LYWu/3p2Z5Yzh9G525r01r0pvAJ/BVCnLL7wSiue9B4CN3vOzDOQgws5HVUgxBwMgRxFUv78R/MiCIhKDbyjpTe0Zw9ndLOQghhJECDQ58fNv5XRwBhRPWlDCGIEqobJpw8ku/oKHIIjrScfNo3jpG18QvVNvCzGH1fAhRavh5liWcHIvh82DBDcva8sOYyvp5jsfVcFmdDMkwDeV9JRvqePmCEoQp7s5L6pJF047bpZR2bTIzSsCBbjE3KHgtg3nyFS8oRlZ11aTKyIuEN9Usf9sEZobAeDwDWX8eDiH3gqheSFCVe72g8uVHDFzyjn+k+zfw95/5+PXs9/E//Wf/Vniy1yXi6jcudMNbjtM842xmENzQqhehFZWS71IiFQJ0Zh0Yyerr06rBYIgbiTX4bw8FzhHpuyieNpf5NCxNZzdzSzVzZ41RzefO8hUhZubWV1kFF2D2hbjyJ073eC2w1TfWCz2NGtuOMbN8tjgvpXT0cqRm1cRCnCJuULBrUD1Qmw/rHWLEPSefI1mgEzZRWNENcWFwBj8US0Leh8ac2w/rEL1RBl9sSdI9AjWnbCbopMpuzj/pxJefvqTwGdS+idek4soI6VNwiTEEN95/ly818JpC+UtC43iJb5zzmE0A1h1H7HE0CzoQ6lVBEEQs3Bb3K26IbYfJbvZbIre8Jc6T8+Dy7hZAmJJQqBK0N0LN2fLLqymj8OnCkN91q8bRmu+bi5t25drucc5zGYAs+4jlhmaeXLzKkDfADE3bosgx8I5NvfrkCKeeBKWOJCtessPcAeJOQqnLdg1F4yLSsaVTQuxIiF/1oLqRV1ZMg6wkEMO+0UjAUAYI3/WQqNojl2ZXGWilJ7Dg7fxnts4AwJFghbEYi9Qz96c4kkLTiZ9tngkA/0ROYBsxUV5y0ajSP32CIIgxsI5tsa4OVPxlh/gDtJxc9UFw4CbTwfcHAMsjiGH8bCbgxj5cweNooHourX66SGWZnSzKkHzh928dtyEa2uzXa+0r/eMVo+by+7lg2bi0lCAS8wFCm4vUP1oSC6DyKtWRp5z7H63DCW8EH+m6sFseDi8vwa76g1VCu4UchhE4kCu5CJfdtHKaDi7k7lWM8aqFyJ77sJwo6H7+iowMgbEojCUZynwDfEnV3KhnSb397XqPuozTGyYjaCvP2JH0MWTJlo5bXn7swiCuPbcFn+rXgQpGuPmVWu/xjnufqcMORp0s4/D+0VkalO6+dxBruTAyWg4211uOva0qG6IbMmBPqGbmzkNvnnh5vy5Ay2lR63Z8GeaLLbqfje4BS7cvHbcRCur3YiU8OsKBbhEKjzmaDZj8BgwbQmKknwivC1ynBTWyYFJbpEGAJBi0d90VWZRi4+bfcEtgHbxBnRnjadBAgAupFE8aaK8k5nbWK8MzlE8brb3LKVXYAQDDp7OQ444Ak0eFhgf8cXPiF0fvojpDMhoBrQHiCBuEXHM0Wq72bIlyClunoTb5G/G+Xg3RxxSGM9ccHHerB81+oJbQLwFKeKwa97I95JEr5sLJy1UVrjtTxfOsXbchD3GzZwBh88UIIdxipvTD8Gm/SDbWAkTDJ0BGa2QCk4tEQpwiUScVoz9Bx6A9jmBA5tbCoobF1XnrkuxoEXjGzL4GItyJoocrEpgkql5qdLQnRDNrCb6wvXc19vnNe3ySuJitrm8bS9npphzGK0AShDDM0ZXyTRaATIJK9XDr9kuPqElv59WVkP+3ElsFO9kZpNdzFhq24NVat1AEMTV4rQi7D/wL1IvObC5raC4nlIRdgQvvv088O7ch7iy+IYymZud1QlMrLqfnE4N0ZO9ldXEpGzPfbzn71FuzlZcVLas5bvZVEbuWTWaQWIW2SCMA5EipW4DamU15ErJbm7N6GYujXLzTC9JzAn6+IkheMyx/9BDHANxDPBYSPT0JITriPQdCm5HwBjOdjOI2QiNMiBaodSVpBM+IMYfqBKqmxYiTULcPovHDIglhuO9HDxTAR/xXlknd2jByEGE3e9WsLlfR/G4iZ0HVWzu11JXWDuzw6PgALwxVS1DXUF1zUCMnrQpANWigXDG/ojNvN7XmP4CBiet1QFBEDeKOObYf+B3vRx33Hx84eZJefHt5/HyuymFAG8qjOF8jJsZRAHFlYDz0W7WJFS2LIRqgpvvTejmJdB180HbzR9VsTHCzZNMPHMAnjnazYGhoFYcdnNlzZi5FVKjYCS6mYPBJTcvldW5wiZWhmYzTjwjcg5UyiEFtxPgZjQcPlNAvaAPfZQcosqhZ61OAoVnpJ/cG0UTsSzh8OkCzu9kUF0zUN6ycXC/AN9WcfxkHvvPFuGacqJIA00evweX87mn9m4cNqAEMSSO7h+jGSBbSv7dTUt96g4RYna/tDM+pUuJxIt1ms4DQK7qQZpxf5dnqaium+LipfNHAk72stdqfzNBELPTaiSfPzgHqpVwqtf6peBj8xjStcPJaDh6uoB6PtnNkSyJQGkVYAy+nu7mZt4Qbn6mx83bNg7uF+H1uDnN774uT9SCaO5uPmi7Ob5ws9kMkC276WMYNURM4eZw2M35igcpmt3NtV43S2KC4eTecltBEpSiTCTAk+NbAMDaT34PBbcTEqkyyjsZeKaC9eMmAAZwjkgRzdxTT36cQ/VEEYVgEgHNgfJOBtsPqt0gr/P9n92xL/YiMZba8y2WJZS3M9h5UO2mLE8iHRZxFE+asGti9dS1VJR27JlXOjtIUQzdHW4lINKyPNTXraHnNPM6zIY/NFPc+dE1FZzvZsbO9MpBNJROxSDaOWQqLmobw8eehNqGhWbegNESbYJcW6P0ZIK4RcQxT73Wj4fr7qTyzluv44P3CvMZ1DUk1GSU72TgWQNuViWc7K2Wm0s7NrYf1hLcnJnYzaUd4WY24ObyiP23LIqxdtyCXRf7fOfm5jCG7qW52U0swtjM6zB7iix26HXz2W4G8QRutuopbi7P7ubqhoVGXofRCsjNKwQFuMQQpi0lRriKreJt9/7iB3QdaTdetxo+OAMe38tB4mJmb5QYNSfA5kG926MvlhlO72bhm1OkunAOq+7DrnngDGjkDbi2OlLGvqHg6OkCcucONDdEoMuorlsIR8weDxK0XyNbcqA74jVq62b63hrOsf2o2tfiwGgF2PmoisP7hctVBh5VTCLlCtGxVbSymtjz1C73DwZUNkyRhjTheFQvEp/1wHEkLt5fbcK3kESkSmjmqfUAQdxGrIwMIBi6nTEgk5v8XH2bg1ux9zOE2fARM+DoXh4y52PdrLcCbBzUIcUdN0s43cvCH1HXIenYF25maBR0kcY6ys2miqOnCsiVety8YU0VaAZDfldQXTcQjnLzw5rordu+qePmg/uFS1UGZpyn7lllKYuoTkZDK6PBarTd3H5yZcNqu3myYFJzo27dkF4kLvZdX4ZIldHMXy74J+YLBbjEEIrCsLGl4Owk7F6jK7aKB5u7ePTcs8sd3BJQfNFawNeVydJBOcf6UaMbKAGiL1p5yxrZX0+KYtGAvuckL4Uc249q2L9fnEwqA/1SAdFippHXx1YyDjUZpTuXq3YcavLEFZM1N+wLboF2dciYY/ujKs72sjM3S49lhlCVoPr9xowheggmwhjO72RQL4qLHy5JaOam71sbqVJiStVFUS5OqUsEQUyNojCsbyk473EzkwDLkpDJThZ03KSqyYoXQYqndPNhoxsoAUBuEjeHMbYe1fpcJYUxth/WsP9scbLVuoF+qYCoZFwvGGMrGYf6fNw86WvoTgjVj/r2MHbcvPOgirO7s7s5UiREigQpGHZzM5dS6Km9d7rhhDCaPmJJQiunT923NlSlxH3H3ZvIzTcKCnCJRNY2VJi2jGo5xNpPfg/edu/j0XPPgku3Z9u2HETY3K9D9aNuXs8kzbuNVgir3p/qKnqWttDK6qntB6yan7zyyEUlxUmahhutsC+4BS4qGdeL5lQrskkofgTVDSFFIp3LtdSZ94AOBp8dGAA1iLHzURVHTxVmGzNjOLuTwfZDsV4qcbE/JlIkVDdG9KFlDL6pTrdiPkCgK/B1JTFF2miF2Pt2Gcf3ciMrOhMEQSSxvqHCsmRUKyHiCMjmZWSyEtgEF+YvfeMLwA3YYiQHEbb261A6bgZQ2prAzc0AVmPYzWsnLbRyemrWkF3zkl+wvSLbzI/vhmA0g77gFrhIy21cogBhh/m6OTnfnUF4e+dB282zjLldhDPRzeuj3exZKrxLFG4KDAWBLkNzowQ3B8LNT+RmDt6J1YK+RSIV05Tw49/+1du555ZzbD0SwS0DuoHn2nETgS6PDICseno1XrMZpMpQjuLE5zEOyNFkRR6MnpnpoWO3fNT1AYFwDinmiBkbLcOYY/OwDrPRnx7HGXC6lxMp0FMSjJBj5zPPn7dwvpsdfkD7wkJvBYgUCY2CMTRx4JsqDu4Xkam4UP0IrqWildNHz7ZzDs2LEEvsUhccp/eyWD9qdD+vTkELxgEecWzt13Fwv0CzxQRBTI1pSTCt6dua3AiXc46tRzWofpzgZgX+iAJRdn24xkLnJUb1E5dGuXnCwoFmM0h1s9EM0Bj0TcfNEhvpCRZzbBzUYTaH3Xyyl4M3g5tHFbZiABADuXMneUW4182qhEY+2c2HzxRhV12ofgzXUhbm5pN7OawfNrqf16CbN/frOHyG3HwToACXSOU2V0tWvQhKMDzLxziQK7k4u5suDZ52YmRIafUicE0VOTbco40zTFzVMZbTe7LFA6vvRsPH2nETShADDGjkdJS37UTJFE6bMBpB4uexud9O05pyX45vyPANBZoTJpZz7/TgHbo95th+UBUpVO3Z3/y5g5N7uaHZ3ViRJi4cYdZ9rB81RMN3DoSqjNO97EwyFfuzcth+UIUx8B4YxAWT6kW0iksQxEK4KanJmhtBCeJEF2XLDs7NhAnRNp32QEOGG+Nmz1LBS26im90JuyHEacEbG25LZDR8rD1uQgljcCaKLJW27MRJ6MJJUwTPgy/Lga39GvafXZt4j2oHf8RKZ3vI0J2EveDtFGal181nyW6O1CncXPOw/rh54WZNxsledqbWPrEs4fReDtsfVWC4/SvVDGLCQvUjWsW9AdyefFNiKm5zcAuI1dSkM3vnBDiK1J6lXBRLSMOzFHim2u1nBwhBuJY6cYDbzOupvW56G5mrbojNgzrU9oUC4yINa/2wnvjcbMUbebKw6v5E4+uDMZzcy6GZ09IysxODy2zJ6Qa3wEWbgY3D+sztDBQvwsZhHXLMu60LVD/C1sP03nwTkfZUll7siiAIYp4Y77+27CHMDSmKEyeRL+tm1053c8fBQ262J9/Okt7LvP+6QHPabg6FmyUuerRvHDUSxs2RqXoj29tZjdncfHwvP9rNCcFltuR0g1ug182NmT2qeiE2jhr9bvYikeJ8CYemfmZsef2BiflCAS4xxG0PbgHAM5TE4CRmQCszWgWxIrgAACAASURBVGi+oaCyYfX3LGXA6d3s6BQcJnqnlbcseIYCz1BQ3rZxujd5P7VIlUX7gG4/NiCSRCDZO4ubPx9eKe70opMHij+MajbffW48mxG4xFDazaKZ0/ouHgAxO560J8euJaeZSRGHkrKvdxzZ8vDsPAMgx/GlqismvS9ANIGfqvomQRDEDLz0jS/g82/uLHsYc8M3FUgJgU3MRk8gi+cO9BOX2m7em8TNOZQ3LXiGDNdQUNq2cXo3fbV4kFCTcZ7k5r1c37Fz561EN1sNP7GP+jg3s1ndLDOc72bRyqa4OaGWRabmpbg5FpliM5BJc3N0STdn9XQ3X7JWCbEa0BUW0QcFtwIuS6ismyicO90TdqcQQmOCYk/1dROtnAazGYAzhlZGnSyFlzE0iubIio7jcHI69jMa9FYAMCZSqAYC5O7e4oTjy2HUX52QMXimAt0ZLprUIdBk5E+akCMOJ6PByYxufTDI+U4GXGrCbs9GR7KE0pbVl9bEYo7CaTO1AIZ4TIzcmQejKfb/1NfMiQJJOUz5PNp7rKQwblfe5HBsbeK05UbBgF3zoXkhJH5RSfl8N0N7fAiCuHJums9jWRQjyiW5eYIWaqKfuOirGjMGJ6NNlsLLGBprJhoJfVonpZXT4czoZs4AJYzhK/1u9g0ZupvuxECTLuXmszsZrB23e9Wj7eZtu2/lmsUchZPm6AnmATfX1syJtugkpaN3kKJLuLlowK573U4OHTefkZtvDBTgEl0ouO2nvmEhMBTkyi6kMEYrq6FenLwfaqTKaBSWMxPIJQZ3xGy2ayp9Pe4unsgTBVHatrHzsAr0ZG7z9h/XUrF5UO82kbdrHnxDwfETuclFITGUdjIobdmisIY8XFhjc78O3Rnea9QZS6gwbLV7CEsc4I5InT6/k0ktHtLBtdXERvKAaHh/9zvl7s8FtFBbN1GdZP+QxHD8ZA5W3RdiVyQ08jqiS1bMJAiCGMc7b70OvLfsUcyf6obIcsqVXEhRr5snz3RaVTd7pgrVT0g75kCQ0BantJPB9oNq17/th7bdrGBrv9/Nnqng5N6Ubr6TQWl7lJtrqRPgIp1Zwvb+sJvP7mTgjHGzY6tD1aeBiwJfg26urpsT7e3lEsPjJ/P9bi7oM+3rJVaTpQS4jLE1AO8AeArARwB+jnNeTnjcRwDqACIAIef8hxc3ytsFBbfJuBltpIyuK/U1E5maD8S8K6WYAfWCkdgqITAUHD5dQLbkiuqDnCPQZTQKBjb36317HSQuetzaVa/btkH1PDz94bdg12o4272D/fvPJLecklhiMQ7FC6E7w5LriJzLDJ6pwa5d7BXu7C1ee9xEK6uNFHozbyBb9qAEUd+qQCOnY+2kNXTc3LkDx9ZGVuzswhhaOX1skE0Qy4bcfHN46RtfwJdusNNvqptr6ybsutc3mRwzpE6u+x03lx2YzRDgMQJdEW4+qA+1JdKdEHbtorWR6rp45i++Batex+nuLg6eeXoqN6tuCN0JU90cy2I7jl3zu++n4+b14yb2x7m5YCBXcYEg7ndzQUcxwc35cwdORpusgCO5+UazrBXcLwL4N5zzf8QY+2L7519JeezLnPOzxQ3t9kHB7e0j1GQcPZlH8bQJoxUikhlqa8bI9OtYklBbN1HZsrpCMpqB2Mk/kJkktYtWNQsGiicn+Ol/8ZtgcQQ1CBGoKmrFIn7v9Z9HqE12gdLbi7gXBtHS4PFTeez+dSW5GjPnYysWd2Zzs2UHdt1HLDHUi4Yo4pHQA7FTlGuiAJcgrg/k5hsCOf16EmoyHj+ZR+GkBcOZ0M2yhNq6hcrWxeqq0fATnSlxwKp5aOZ1rD0+xk/9xm+CxTHUULi5ur6G3/uFn0ekTlY8a1TPXM+QcfxkHrvfrSRXY45F3YxRve65xHD0ZB7ZstvnZrG3ON3NFapxcetZ1m/AzwD4dPvf/yOAP0K6RIkrhILb1UAKY2SqLuQghmepY1cc50Goyzjdy40fWxSLnq7tvnGhIuF8JwPPVke2VugUzvjRf/U7UL2LlCs1CJA/P8f3/z9fxQc/8smxx2dRDDlI7kMYo11YhDFEkgR1MNLuPG6C1DUuM9Q2rL70Jrs6LNCLJ8xQvCPmsBo+5CiGa6rUJohYNcjNN4Cb0hJoFViGmwNdwem9Gd18JyPaGkkMSREuB8AlAJzjR//V/wrNv6iyrAYBCqdn+P6vfg1/9tKLY4/P2ntgk+gW/WJM+He4qxAYJnWzNOzmips+rlnqarXdLEUcnqmQm28Ay6qivM05PwKA9t9bKY/jAP6AMfYnjLHPLmx0twQKblcDzQlw9ztl5M8c5Coe1o8auPPXVbBoNWrVbz2qw2yIJvWMA2oQY2u/BsWL4JlKYsuGTrqzVatBCjgcO9enWSWKcP/DD8ce26662Pt2GcWzFtot8LpwAJBYd2a7vmYMV3uESOGadV+NYyfPYnOGqdOaVC/E3nfKWH/cQOGkhZ0HVWzsz97aiCCuAHLzNeeFV2avLEv0o7cS3PxRdebKxHOFc2w9rA27+VENit9xc8LTWLv4YbUGFktoJbn5mxO4udJ286mo+jzkZnbh5tqamehm11AQK7OFIWkVszkT3QumQXVD7H27jPWjBoonTew8qGL9gNx83bmyKQrG2L8GkFSb/h9M8TKf5JwfMsa2APwhY+xbnPM/TjneZwF8FgC21dmr3N0WKLhdETjHxmFjaJ+MEkTIlRxUNydrhH5VqF4I1RsuHsE4kC07KO9kcHIvh62HNfGYthDqBQOxxLBxFODrn3oVAKB5Dr7/q3+EbK0EAImBcS+KH2HtcVN8Nj2fT69yGlmtW/G5ldWgeiZyJQecMTDOEWjyVK0cBokVUTFy7bjZnRXmTPQ0nLQ3sXgSF3uVI973WZpNH5mKe6mq2QQxDeTmm8sLr4R4VXpj2cO4GaS52Y+QLTkTFTK6SlQvSqy4LNzsorxt42Qvi61HdbCe2eF6se3m0xBf/+QrAADNdfCxr72PTE1stx/rZi/C2nEzcd9th0ZO6wavrawGzTWQLbt9bj67pJvLWxaKJ60+Nzfy+sS9icWTuNirHPe72Wr4cHvqiBDXjysLcDnnP5F2H2PsmDF2h3N+xBi7A+Ak5TUO23+fMMZ+C8AnACRKlHP+ZQBfBoDvNQs07TICCm5XByWIE5vTd/awLjXA5Rz5k+GefIBILersvfENBfvPFmE22+k9lopIZtj7ThlSDMSKkI0rK/jgpZ/C3/zD/xlgwF/9wMdGHt6ueqnH7pCpeXAzKpysDjCG6qaFetGA5oWIZGkuaUbNggHPUmHVPNGKIKNNJ1BcfM+Dlw0SBzJVjwJcYmGQm28uFNzODyWIIUXJbs7UvOUGuFy0zEvzo9Jxs6n2udm1Rery3UE32wq+/tJP48U//E1wxvD/Pf8DIw+fqQ73pu0c++IxHtyM1k1TrmzZqK2Zws2KhEC/vJsbRROuLYpLgnM4GX3quhiqH6W7uUIB7nVmWSnK7wH4u+1//10Avz34AMaYzRjLdv4N4CcB/PnCRnhDoeB2tRi5h3XJvdh0J4TZTG7LEzPRHqiLxOBkdTQLBkJNhl3zh4pbgDHETMLxvWdwdmcHH/6N0YVXpQnSwCQO5Er9e3FiRYJrT1hFcUJCTUZtw0J10546uAVEoav0+y4zMoKYK+Tma4rx/mvLHsKNYqXd3AphNJPb8sQM8Kwe9/W4OVLldjA48KSOm+8+g5PdXXzrhz4+8viDq52Jj+FAttR/rdl18xyC2w6hJqPadfMMrzvCv6O8Taw+y9pF/Y8A/CZj7O8BeAjgZwGAMbYL4H/gnL8KYBvAbzFxIlEA/HPO+e8tabw3AgpuV49IlRFoMrSBnrSdMvjLpNPYfRCxvwYjqzrKYUpRKEXBhz/0N3D4zHZ6oQ7OobkhOBPHGivSFdmrPIpAkxHLDFLYP1bRiujmtbogri3k5msIuX3+RKqMUJOH+sXHDKjnV9fNvGfvaxJyT7udXmJFwTc/8QkcPj3ezTFjiDF+hUy+Dm7WZVGQKxp2c3PJ3zNxOZYS4HLOzwH8eMLthwBebf/7uwB+cMFDu7GQAFeXs7tZbD+sihXL9jnWtVXRpmaZjHBTedMaWRzCsxTw0vDqZCwxnN9ZTxUoizi2H1WheiLFqlMDsvfvvtcD4GSmX1FdOIzhbDeLrUc1AGJ2OwYQaBKlJxMrA7n5ekJuvxpO72ax/aDal03k2CoaS3bzqKyfyqaZ2Mu+g2upyJbdoSA3lhjORro5xvaj2uRuZkDrOvQpZgynu1ls7fe72ddk1Ck9+VpDdbBvARTcrjahJuPgfhFmI4AcxitTor6Z18VM8WAhCQY0x1QQdi0VvqFAc8O+5uyeqY4szlQ8aUL1oj75cgCBKiGSmVjp5u32AqzT/+96BIiepeLgfhGZigO7FkD1I2ieqHpZ2rHnmrZFEMTtgFoCXR2hJuPg2dV0s1VPc/PooMy1k93ccXYaa8dNqG7Ut2o7ys2RIqG+dj0CRM9WcXi/CLvswK77UP0Yuhdh+1EN5zuZkX16idVl+f9TiSuFgttrAmNwsqs12+mZChoFHZmKEGlnT9L5jg0+YoYYAMAYju/lkK24yLR7ydbzupj5HrF/ya55QzPLDCLl+fD+OjQ3RLbkQAliOBkV9YIxfixXjOKFyJZdKEEM11LRKOipY4oVCWYzhBJcpL3pToidBzUcPFOYuWUCQRAEcQWsoJtdSxET0NUBN9/JgI/rK9txc9lFpuaBQ1QeHulmzmHX/eGKzQDkqO1mJ0S27EAOYrgr4mbVC5HpuNlW0cinuzmSWdvN8YCbqzgkN19LKMC9wVBwS1wKxlDezqCRN2A2fHCJoZXVJu8pKzHU10zU1yZcYeU8NfWqc7tvKDjfHdFaIOZgnC9MrEbDx+ZBvTtzbbQC5Moujp7KJwpRdcO+mXOgneLFObJld+ltoQiCuD7Q6u0thTGUdjKoF3rdrHdb5o1FYqivm6hPk/00zs2mgnNzddxs1n1sHPa7OVt28fipfGIKt+ZG0LxhNzPOkam4S28LRUwPBbg3FApuiXkRGAtKy2IMrqXCaPVXbuYQaVXiBw6r7kP1IwSajFZWtCBgUYz1x01YDVG9OdAklHYy8Kwr3J/LOTaOhvskIoyRO3dQ2baHntJprTSIxAHNC69ooARB3DQouCUW6mZTgeGEQ252Om6OOazGJG6WcX5ntm4EE8M51h8nuDlou3lrWjcn30esNrTmfgOh4Ja4rpR2bMSSqNAIiGIPMQNKWxakMMbd71SwftRA/szB+lEDu9+tQApjbO3XYdb97myt5ou9rUqKtOaBEsRgCa2MJIgm8UkEKXt5YgZ4K7C3iyCI1efFt59f9hCIW0ZpJzPsZgkobVqQgwh3v5vs5u1HtQE3R9h+WIMcXJ2bVT9Kd3M92c3+SDfTHtzrCAW4NwwKbm8+eivA2lEDGwciqMMlerVJYYzcWQvrh3Vkyk6iFBZJqMk4fiIL9LQIYgA2DxtYO6pDDkWLAwYxs6oEMTYO6yLtd+C1GAeyZXfoGPMillhqC6NYSr4n0BV4poq45+5JWjsQBEEAIrh9+d1PLXsYRAJ6K8D6UQPrh3N2c8Vdvpt1GSf3BtzM225+3Eh08/pRQxSNHHitRbg59b6UFOnAUOCbSqKbm+TmawktGdwgKLi9+eRPW8iVnO5sqNnw4doqTu9mRxZvSkJzQ2w/rAJcCMmq+8ifp+8fXRRrx63u+wOEDBU/guoNtyIQe2tCxBKG9ggxiCITV0WsSPAMBfpA2lbMMLJ65OleFoXTFjJVDyzmcG0VpW2bilgQBDGWXwo+tuwhEAkMutmq+3AyGs52M9O72Wm7GRduzp07qftHF0WSm0U3gGQ3m80APNXNV7eCG6kyAl1Uih50c21Ei6eTvRwKJ01k2t0jHEtFedte6mdOzA4FuDcECm5vPnIQId8WaAeJA0YzgNEK4NrTVXpcP2pAii9+ljjAwhj5sxbKO5k5jXo6WMSHAsbO2EbNXycVp+q0PpgU1QuRP3OguSFCVUZ1wxy7h/f0bhbbD2tQggiciXE08vrINkpcYihv2ygn7NElCIJIw3j/NXzwZmHZwyAGUPwIuZIztOfTbPjQWyE8e7r9phtH9aHXYkGM/KmD8s5yvCFF8VDA2Blbmpt5p0nuAKJl4OThh+qFyJ860LwQoSajuj6Zm7ceVaEEMTgT46wXDLRy6ddJXGIo72SWdv1DzBcKcG8AFNzeDsxmkNhQnXFRMXCaAFeK4sQZVAbArvso7yQ/j8UcVt2DEsTwdQVORp16dnpWOp4cLHLRzGoAE7PcnYuCadN+VVe0A+jMTitBDP1RgLM7GTgjgtVYkXD0dB6aF0EOYviGPHmVaYIgiCn4/JspJ2ZiqRjNIPF2xkU9hmkCXCmMoQTx0O0MgNXwUEZygMtiDqvmQQlj+IYiij8t2c2trCauTxoDbpaYaEs0AZobYnvQza0AZ3ezcDLp1zyRKuHo6QI0N4IcxvBNBRFlSd0qKMC95lBwe3uIJdbuKZNy3xSMWg3lKVJU/EgEgTHv9t4LNRmPn8jNrfQ/lxk8czjttzew74ydt5vJixQihkB3kC17kGIOx1ZR3rQmTvstngykXkFcnKydtHDQrgaZCmPwDQWgbToEQVwRVDV5deGj9nxO6eY0xwMj3OxF2HnY7+ZAk3H8RH58X9wJiWUJviFDc6PxbpaASJZQ3hJuzp07yFZcSDHQslVUtqyJ034LJ82E1j1A8bg5PohnDP4UK8XEzYK++WsMBbe3i7TZSs6AZn666IrLUmJLnpgB9ULyiuXGYQNSxIf2xubPklvizMr5nUx7NZWD9UxkD0q1vGn1NaevrVuorc/Wq05PSL0CADkUlZLndZFAEAQxLcb7rwFvLnsURBqtjIa1hNuFm9MzgJKIZSmxJU/MgEaam4/qQ25W/Qj581ZiS5xZOdvN9k1ydxhy88aAmzesmfvI6k5yHQ0liLvBPEEkQev11xQKbm8fXGI42cuJUv2SKNEfM6C0bSNMKXE/irPdDEJV6r5OZ89qLaH5Oxux/8aueTO+o2RCTcbB/SJK2xk0c5rY25rwONWP5paCFaUEsJyNnp0nCIK4aig1ebXhMsPpXq7Py103a9O7+bzjZtbjZltFbW3YzWJvbLRYN++McXMQz8/NKVlYnFFwS4yGVnCvIRTc3l48S8WjZ4ti5ZVzuJY6c3pwrEg4fKYAoxVCDiL4hoJAlyFFHJzxuaUdzwKXGJp5HZwBVm24b53YizO/KozVdRNrx/2pUN0Z8wXtYyIIghiEUpOvB66t4tGzazBbAXBJN0eqfK3dPM8et7U1A8WT1pCb6wWD3EyMhALcawYFtwQkBndEcYWpYAyurQJQoTkBdr9bgRLGABeruWe7GcSKBC5LiXtj4xlSsKbB05XEGWIOscdnXjTzOpQwRu5c/N9iAJo5HeU5pncRBEFMwztvvQ68t+xREBMjsZGFj6aix816q8fNaLv5jnBz2t7YmAGNEQUSL4uvSalunmdbnUbBgBxy5EoO0O5U0MzrqGzNlvJM3B4owL1GUHBLXBVyEGH7Ya1vltRoBdh+WMXR0wWAsYu9sQOFLKoz7q2ZBLWn/U4vDIAczrHxPWOobliorZmQgwhRO6gnCIJYBi994wv4Evn+1iP7EbYeDbi5GWD7UQ1HT+UBxob2xnIGBLo8877XSVADntzVAaJ2xdxgDNVNC7V1E0oQISQ3ExNCAe41gYJb4irJlN3EZuxKEEN3QniWilCTsX+/CKvht9sEyWKG+QrThNL2v3IAXJn/cbnEEOp0WiQIYrmQ7wkAyFbcxAlexY+guSF8U+3ujTXrPpQggm8qogf8Fbo5rauDWMG9GjcH5GZiCui35RpAwS1x1ahBnFxxjokgt1uqQmJoXWHa0yCeqSCWGVjI+ys1dvbgEARB3DAoNZnooPrDBaQ6KEEMv113iksMrSvcLjSIZymIJQYWJbh5wh63BHGV0Dr/ikPBLbEIXFNBnLKhxjOWOA/GGE7u5RDJonJ01K5QWdmw4Fnq8sZFEARxBRjvv4YP3issexjEiuBaarKbAdF/fVm03RzLrNvZgTOgsmnBN8nNxPKhFdwVxnj/NQpuiYXQzBvIl1ywMO7OxsZM9N6dpQXRPAl0BQfPFqG3QkgxFzPHtAeHIIgbCLUEInpp5HXkSk5fFlPMgFZWm6kF0TwJDAX75GZiRaEAd0X50mc+R43diYXBZYajp/LIn7Vg1X1wiaFeMFBfW5FUI8bg2TQrTBDEzYVaAhGDcFnC0VMFFM5aMDtuLhqrkwZMbiZWFApwVxCSHLEMYkVCeSeDMi0gEARBLJQXXgmXPQRiRYkVCaWdDEBuJoiJoVyCFYOCW4IgCIK4PbzwSohXpTeWPQyCIIgbAwW4KwQFtwRBEARxe6DgliAIYv5QgLsiUHBLEARBELcL69d+ZdlDIAiCuHFQgLsCUHBLEARBELcLagNIEARxNVCAu2QouCUIgiCI2wcFtwRBEFcDBbhLhIJbgiAIgrh9kP8JgiCuDgpwlwTJjSAIgiAIgiAIYr4sJcBljP0sY+ybjLGYMfbDIx7304yxv2SMfZsx9sVFjvEqoeCWIAiCWDVuu5sXBV0DEARBXC3LWsH9cwCvAfjjtAcwxmQA/wTAKwC+D8AvMMa+bzHDuzpIbARBEMSKcmvdvCiM919b9hAIgiBuPMoyDso5/wsAYIyNetgnAHybc/7d9mN/A8DPAPjwygd4RVBwSxAEQawqt9XNi+LFt5/Hy2/uLHsYBEEQN55V3oN7F8Cjnp/327ddSyi4JQiCIG4AN8rNi+LFt5/Hy+9+atnDIAiCuBVc2QouY+xfA0iaqvwHnPPfnuQlEm7jI473WQCfBYBt1ZxojIuCgluCIAhiFSA3LwcKbgmCIBbHlQW4nPOfuORL7AO41/PzHoDDEcf7MoAvA8D3moVU2S4aCm4JgiCIVYHcvHiM918D3lz2KAiCIG4Pq5yi/FUAzzHGnmaMaQD+DoD3ljymqaDgliAIgrhhXHs3L5IXXgnxedp3SxAEsVCW1SboP2SM7QN4EcDvMMZ+v337LmPsKwDAOQ8B/H0Avw/gLwD8Juf8m8sY7yxQcEsQBEFcJ26DmxfNq9Ibyx4CQRDErWNZVZR/C8BvJdx+CODVnp+/AuArCxzaXKDgliAIgrhu3HQ3L5p33nqd1rYJgiCWwCqnKF9LKLglCIIgCOKD9wrLHgJBEMSthALcOULBLUEQBEEQdD1AEASxPCjAnRMkM4IgCIIg6HqAIAhiuVCAOwdIZgRBEARBvPj288seAkEQxK2HAtxLQsEtQRAEQRAvvBLi5Xc/texhEARB3HoowL0EFNwSBEEQBAEAv/q3f3HZQyAIgiBAAe7MUHBLEARBEAQgWgJR1WSCIIjVgALcGaDgliAIgiCIDhTcEgRBrA4U4E4JBbcEQRAEQXSg6wKCIIjVggLcKSCJEQRBEATR4YVXwmUPgSAIghiAAtwJoeCWIAiCIIgOL7wS4lXpjWUPgyAIghiAAtwJoOCWIAiCIIgOFNwSBEGsLhTgjoGCW4IgCIIgerF+7VeWPQSCIAgiBQpwR0DBLUEQBEEQvbz0jS/g0190lj0MgiAIIgUKcFOg4JYgCIIgiEEouCUIglhtKMBNgIJbgiAIgiAGoesDgiCI1YcC3AFIXgRBEARBDEItgQiCIK4HFOD2QMEtQRAEQRBJUNVkgiCI6wEFuG0ouCUIgiAIIol33np92UMgCIIgJoQCXFBwSxAEQRBEMi+8EuKD9wrLHgZBEAQxIbc+wKXgliAIgiCIJF54JaTUZIIgiGuGsuwBLAvj/dfw+Td3lj0MgiAIgiBWFApuCYIgrh+3MsD90mc+B7y57FEQBEEQBLGqGO+/RtcKBEEQ15BbF+BSSjJBEARBEKN48e3n8TJleREEQVxLbtUeXApuCYIgCIIYx8vvfmrZQyAIgiBm5NYEuBTcEgRBEAQxDrpeIAiCuN7cigCXZEUQBEEQBEEQBHHzWUqAyxj7WcbYNxljMWPsh0c87iPG2DcYY19njH1tlmNRcEsQBEEQ41mkm1cVumYgCIK4/iyryNSfA3gNwFsTPPZlzvnZLAchUREEQRDExCzEzavKi28/D7y77FEQBEEQl2UpAS7n/C8AgDF2Zceg4JYgCIIgJmcRbl5VXnz7eSosRRAEcUNY9T24HMAfMMb+hDH22Umf9P+zd+/hkZ31neC/v3PqKpWk0rXVUl99gVyYppNlCO14NnaGzdA2CYyTkMSbMLmaXWfW8NBZ4jg7sJkk80wYJ7thyQxmn/QQEiYxGQfSM0ASsmOGJIQEHhZjGAxraHdLre7WXapS3c7lt3+cKqkup0pVUlWdUtX38zxtt1QXvarurq9+73nf33sjOd3BIREREQ20A2Vzr2JxS0TUXzp2BVdE/hKA3yFyv6yqf9rk03y3qi6JyAyAT4rIC6r66Tpf7xEAjwBAdJQFLhERUbUgs/lYOH6gMXfa26xXBD0EIiJqo44VuKr62jY8x1Lx/8si8hEArwbgG6Kq+n4A7weAkeN362G/NhERUb8JMpu/JZ7suWx++qmH8dyVZNDDICKiNurZJcoiMiwiI6XfA/g+eA0wiIiIKAD9ls0sbomI+k9QxwT9UxFZBHABwMdE5M+Ln58TkY8X73YMwF+LyHMA/h7Ax1T1z4IYLxERUb8btGxmM0oiov4UVBfljwD4iM/nlwA8UPz9NwG8sstDIyIiGkiDlM3nL9pBD4GIiDqkZ5coExEREXXCA8ZjQQ+BiIg6hAUuERERDQwuTSYi6m8scImIiGgg3PP8paCHQEREHcYCl4iIiPrePc9fwn2PZ4MeBhERdRgLXCIiIup7LG6JiAYDC1wiIiLqa08/9XDQQyAioi5hgUtEJXL2VgAAIABJREFURER968Llc3juSjLoYRARUZewwCUiIqK+df8z9wY9BCIi6iIWuERERNSXeCQQEdHgYYFLREREfef8RTvoIRARUQBY4BIREVFfOX/RxgPGY0EPg4iIAsACl4iIiPoKi1siosHFApeIiIj6RuzZh4IeAhERBSgU9ACIiIiI2uGe5y/hvsezQQ+DiIgCxCu4RERE1BdY3BIREQtcIiIiOvJ4JBAREQGAqGrQY2g7EVkBcO0QTzEFYLVNw+lHfH32x9eoMb4+++Nr1Fg3X5/Tqjrdpa/Vt5jNHcfXZ398jRrj67M/vkaN9UQ292WBe1gi8nlVfVXQ4+hVfH32x9eoMb4+++Nr1Bhfn8HDP/PG+Prsj69RY3x99sfXqLFeeX24RJmIiIiIiIj6AgtcIiIiIiIi6gsscP29P+gB9Di+Pvvja9QYX5/98TVqjK/P4OGfeWN8ffbH16gxvj7742vUWE+8PtyDS0RERERERH2BV3CJiIiIiIioL7DArUNE/o2IvCAiXxKRj4hIMugx9RIR+WER+YqIuCISeLe0XiEirxORr4nIiyLyeNDj6TUicllElkXky0GPpReJyEkReVZEvlr89/XWoMfUa0QkJiJ/LyLPFV+jXwl6TNQ9zObGmM3+mM2NMZsbYzbvr9eymQVufZ8E8ApVPQfg6wB+KeDx9JovA3gIwKeDHkivEBETwO8AuAjg2wD8mIh8W7Cj6jkfAPC6oAfRw2wAl1T1WwG8BsDP8+9QjTyA71XVVwI4D+B1IvKagMdE3cNsbozZXIXZ3JQPgNncCLN5fz2VzSxw61DVv1BVu/jhZwGcCHI8vUZVv6qqXwt6HD3m1QBeVNVvqmoBwB8BeEPAY+opqvppAOtBj6NXqepNVf1C8fcpAF8FMB/sqHqLetLFD8PFX2wmMSCYzY0xm30xm/fBbG6M2by/XstmFrjN+WkAnwh6ENTz5gEslH28CL4B0gGJyBkA3wHg74IdSe8REVNEvghgGcAnVZWv0WBiNlMzmM3UNszm+nopm0NBfeFeICJ/CWDW56ZfVtU/Ld7nl+EtTfhQN8fWC5p5faiC+HyOV5aoZSKSAPAMgLep6nbQ4+k1quoAOF/cf/kREXmFqnLvWJ9gNjfGbG4Zs5nagtncWC9l80AXuKr62ka3i8g/A/B6AP9YB/A8pf1eH6qxCOBk2ccnACwFNBY6okQkDC9AP6SqfxL0eHqZqm6KyKfg7R1jgdsnmM2NMZtbxmymQ2M2N68XsplLlOsQkdcB+EUAP6CqmaDHQ0fC5wDcLSJnRSQC4EcBXAl4THSEiIgA+F0AX1XV3wp6PL1IRKZLnXNFJA7gtQBeCHZU1C3MZjoAZjMdCrN5f72WzSxw63svgBEAnxSRL4rI+4IeUC8RkX8qIosALgD4mIj8edBjClqx8ck/B/Dn8BoQfFhVvxLsqHqLiPwhgL8F8HIRWRSRnwl6TD3muwH8BIDvLb7vfFFEHgh6UD3mOIBnReRL8H5w/aSq/ueAx0Tdw2xugNlci9m8P2bzvpjN++upbJYBXN1DREREREREfYhXcImIiIiIiKgvsMAlIiIiIiKivsACl4iIiIiIiPoCC1wiIiIiIiLqCyxwiYiIiIiIqC+wwCUaYCLyZyKyKSI8ZoWIiKgHMJuJDocFLtFg+zfwznYjIiKi3sBsJjoEFrhEA0BE/qGIfElEYiIyLCJfEZFXqOr/AyAV9PiIiIgGDbOZqDNCQQ+AiDpPVT8nIlcA/BqAOIA/UNUvBzwsIiKigcVsJuoMFrhEg+NfAvgcgByAxwIeCxERETGbidqOS5SJBscEgASAEQCxgMdCREREzGaitmOBSzQ43g/gXwD4EIDfCHgsRERExGwmajsuUSYaACLyZgC2qv4HETEBfEZEvhfArwD4FgAJEVkE8DOq+udBjpWIiGgQMJuJOkNUNegxEBERERERER0alygTERERERFRX2CBS0RERERERH2BBS4RERERERH1BRa4RERERERE1BdY4BIREREREVFfYIFLREREREREfYEFLhEREREREfUFFrhERERERETUF1jgEhERERERUV9ggUtERERERER9gQUuERERERER9QUWuERERERERNQXWOASERERERFRX2CBS0RERERERH2BBS6RDxH5iojcV+e2+0RkscFjPyAiv9axwR0hIhIXkf8kIlsi8sctPO6UiKRFxOzk+IiIqLcxj9uDeUyDhAUuDRwReUlEXlv1uZ8Ukb8ufayq366qn+r64BqoHuMR8UMAjgGYVNUfbvZBqnpdVROq6rRrICJyRkS0GNSlX/+iXc9PREStYR53VS/l8WtE5JMisi4iKyLyxyJyvOx2EZHfEJG14q93i4i06+tT/2OBS0RNKQZOq+8ZpwF8XVXtTozpgJLFsE6o6q8GPRgiIqJW9EEejwN4P4Az8MaVAvDvy25/BMAbAbwSwDkArwfwlu4OkY4yFrhEPspnlYvLej4gIhsi8t8A/MOq+36HiHxBRFIi8jSAWNXtrxeRL4rIpoh8RkTOVX2dXxCRLxWXDT0tIhWPb3K8PyUiXy2O4Zsi8pay274sIt9f9nFYRFZF5Hzx49cUx7UpIs+VLwUTkU+JyK+LyN8AyAC4w+drf2vxfpvFpWQ/UPz8rwB4J4AfKV4t/Rmfx75aRD4vItsicltEfqv4+dLV1pCIXKi66poTkZeK9zNE5HER+UZxlvfDIjLR6utHRES9iXm8e9++yWNV/YSq/rGqbqtqBsB7AXx32V3+GYDfVNVFVb0B4DcB/GRTfwBEYIFL1Ix3Abiz+OufwHvjBQCISATARwH8PoAJAH8M4AfLbv9OAJfhzTxOAngKwBURiZY9/5sAvA7AWXgzlT95gDEuw5vhHAXwUwD+j+LXBoAPAvjxsvs+AOCmqn5RROYBfAzArxXH/wsAnhGR6bL7/wS82dQRANfKv6iIhAH8JwB/AWAGwP8C4EMi8nJVfReAfwXg6eLV0t/1GfdvA/htVR2F9/p+uPoOqvq3pSuu8GZ9PwvgD4s3PwZvlvd7AMwB2ADwOw1fKeCaiCyKyL8Xkal97ktERL2DedxfeVzy3wP4StnH3w7gubKPnyt+jqgpLHBpUH20OMO5KSKbAP5tg/u+CcCvq+q6qi4AeE/Zba8BEAbwf6qqpar/EcDnym7/OQBPqerfqaqjqr8HIF98XMl7VHVJVdfhhdP5Vr8ZVf2Yqn5DPf8VXsD9o+LNfwDgAREZLX78E/B+AAC8oP24qn5cVV1V/SSAz8ML3ZIPqOpXVNVWVavqS78GQALAv1bVgqr+FwD/GcCPNTl0C8BdIjKlqmlV/ew+938PgB0Av1z8+C0Afrk4y5sH8L8D+CERCfk8dhXebP9pAP8dvB8QPtTkOImIqDOYx55ByuNdxavo7wTwv5Z9OgFgq+zjLQAJEe7DpeawwKVB9UZVTZZ+AXi0wX3nACyUfXyt6rYbqqp1bj8N4FJVeJ8sPq7kVtnvM/De2FsiIhdF5LPiNWzYhBeIUwCgqksA/gbAD4pIEsBF7BV2pwH8cNX47gVwvOzpy7/3anMAFlTVLfvcNQDzTQ79ZwC8DMALIvI5EXl9g+/xLQDuA/Bw2dc7DeAjZWP/KgAHXiONCsXA/nzxB4PbAP45gO8r+0GDiIi6j3m8N76ByOOy57kLwCcAvFVV/6rspjS8K+AlowDSVX+2RHU1nFUhIgDATXghWFo+c6rqtnkRkbI33lMAvlH8/QK82eZf79TgisurngHwZgB/qqqWiHwUQPlM5+8B+Fl4/+b/trinpTS+31fVn2vwJRoFyhKAkyJilIXcKQBfb2bsqvr/Afgx8ZplPATgP4rIZPX9ROQfAfhVAPeqavms7gKAn1bVv2nm61V/+dLTH+CxRETUfczj+o5UHovIaQB/CeBXVfX3q27+CrwGU39f/PiVqFzCTNQQr+AS7e/DAH5JRMZF5AS8fS0lfwvABvBYsQHDQwBeXXb7/w3gfxKR7xLPsIg8KCIjBxyLiEis/BeACIAogBUAtohcBPB9VY/7KIDvBPBWeHuASv4AwPeLyD8REbP4nPcVv89m/B28JUrvEK9Zxn0Avh/AHzX5zfy4iEwXw3iz+Gmn6j4nATwN4M2qWh3U7wPw68WghIhMi8gb6nyt7xKRlxcbYUzCW171qaqAJiKi3sU8ru8o5fE8gP8C4HdU9X0+d/kggLeLyLyIzAG4BOADzXwfRAALXKJm/Aq8ZT5X4e2l2Z1pVNUCvJnOn4TXUOFHAPxJ2e2fh7fv573F21/E4ToB3gMg6/PrMXjBvwHgYQBXyh+kqll4s8pnq8a3AOANAJ6AF8gL8PbBNPXeUPz+fwDeMqtVeHun3qyqLzT5/bwOwFdEJA2vwcWPqmqu6j7/GMAsvNnkUufG0kzubxe/178QkRS8hhffVedr3QHgz+AdR/BleHuvmt2bREREwWMe13HE8vhn4WXyu8qeJ112+1Pw9kA/Dy+vP1b8HFFThMvZiQaDiLwTwMtU9cf3vTMRERF1BPOYqLO4B5doAIh3Ft3PwOvYSERERAFgHhN1HpcoE/U5Efk5eEudPqGqnw56PERERIOIeUzUHVyiTERERERERH2BV3CJiIiIiIioL7DAJSIiIiIior7Ql02mkqGIzoaHgh4GERH1ga/ltlZVdTrocRx1zGYioubdSDJ2GknferFuNvdlgTsbHsLlu+4NehhERNQHvvvLH7sW9Bj6AbOZiKh5Tzz4aNBD6Gn/9TcerJvNXKJMREREREREfYEFLhEREREREfUFFrhERERERETUF1jgEhERERERUV9ggUtERERERER9gQUuERERERER9QUWuERERERERNQXWOASERERERFRX2CBS0RERERERH2BBS4RERERERH1BRa4RERERERE1BdY4BIREREREVFfYIFLRERERETUI2LPPhT0EI40FrhEREREREQ94u1PzgY9hCONBS4RERERERH1BRa4RERERERE1BdY4BIREREREVFfYIFLREREREREfYEFLhEREREREfWFwApcETkpIs+KyFdF5Csi8laf+4iIvEdEXhSRL4nIdwYxViIiokHAbCYioqMuyCu4NoBLqvqtAF4D4OdF5Nuq7nMRwN3FX48A+HfdHSIREdFAYTYTEQWIZ+AeXmAFrqreVNUvFH+fAvBVAPNVd3sDgA+q57MAkiJyvMtDJSIiGgjMZiIiOup6Yg+uiJwB8B0A/q7qpnkAC2UfL6I2aImIiKjNmM1ERHQUBV7gikgCwDMA3qaq29U3+zxE6zzPIyLyeRH5/KZTaPcwiYiIBgazmYiIjqpAC1wRCcML0A+p6p/43GURwMmyj08AWPJ7LlV9v6q+SlVflTQj7R8sERHRAGA2ExEF5/e+Hgt6CEdekF2UBcDvAviqqv5WnbtdAfDmYsfG1wDYUtWbXRskERHRAGE2ExEF58Llc3juSjLoYRx5oQC/9ncD+AkAz4vIF4ufewLAKQBQ1fcB+DiABwC8CCAD4KcCGCcREdGgYDYTEdGRFliBq6p/Df99POX3UQA/350RERERDTZmMxERHXWBN5kiIiIiIiIadPc/c2/QQ+gLLHCJiIiIiIioL7DAJSIiIiIior7AApeIiIiIiIj6AgtcIiIiIiKiAD3x4KNBD6FvsMAlIiIiIiKivsACl4iIiIiIiPoCC1wiIiIiIqKA3PP8paCH0FdY4BIREREREQXkC6tXgx5CX2GBS0RERERERH0hFPQAiIiIiIiIBtH5izYeeHI26GH0FV7BJSIiIiIior7AApeIiIiIiCgADxiPBT2EvsMCl4iIiIiIiPoCC1wiIiIiIqIuiz37UNBD6EsscImIiIiIiLrs974eC3oIfYkFLhERERERUZc9dyUZ9BD6EgtcIiIiIiKiLrrn+UtBD6FvscAlIiIiIiLqord+5mbQQ+hbLHCJiIiIiIi6iMuTO4cFLhERERERUZecv2gHPYS+xgKXiIiIiIioSx4wHgt6CH2NBS4REREREVEXsLlU57HAJSIiIiIi6oIvrF4Negh9jwUuERERERFRF7z9ydmgh9D3WOASERERERF12IXL54IewkBggUtERERERNRh9z9zb9BDGAiBFrgicllElkXky3Vuv09EtkTki8Vf7+z2GImIiAYJs5mIqP1izz4U9BAGRijgr/8BAO8F8MEG9/krVX19d4ZDREQ08D4AZjMRUVtx7233BHoFV1U/DWA9yDEQERHRHmYzEVF78Wig7joKe3AviMhzIvIJEfn2oAdDREREzGYiIupNvV7gfgHAaVV9JYD/C8BH691RRB4Rkc+LyOc3nULXBkhERP2LHS99MZuJiJp0/qKN+x7PBj2MgdLTBa6qbqtquvj7jwMIi8hUnfu+X1VfpaqvSpqRro6TiIj6y4XL5/D0Uw+z46UPZjMRUfN+6Y1vDnoIAyfoJlMNicgsgNuqqiLyangF+VrAwyIioj72xIOPAs8EPYrexWwmImrec1eSQQ9h4ARa4IrIHwK4D8CUiCwCeBeAMACo6vsA/BCA/1lEbABZAD+qqhrQcImIqA+dv2hj6N2/yCVkRcxmIqL2ePqph4ErQY9i8ARa4Krqj+1z+3vhHVVARETUdk8/9TCeuJIEWNzuYjYTER3e+Yu2ly/UdT29RJmIiKjdzl+08UtvfLO3bIwz60RE1AFD7/5FTp4GhAUuERENjNizD+GBJ2dZ2BIRUUdx20twWOASEQDAshSOrYhEBYYhQQ+HqK2eePBR7zdPBjsOIqJWMJuPpt3MoUCwwCUacI6jWFooIJtxIQKoApMzIUxOhYMeGtGhnL9o44V3vAlvf3I26KEQEbXEL5unZ0IYZzYT7YsFLtGAu7lYQCbjAuoFKACsLduIRAyMjJrBDo7oAJ5+6mEA8Jp78IotER1BSwsFZHZcAHvZvLJsIxw1kBhhNvey2LMPMXsCxgKXaIDZtnoBWnXAhyqwvmqxwKUj5Z7nL3l7nri/loiOMNtSZDNuzee9bLZZ4PawC5fP4X6uGgocC1yiAeY4CghqClwAcOyuD4foQHYLWzb0IKI+YDfIZtvmkdO97P5n7g16CAQWuERHhmMrXAVCIUCkPY0mIhGpl6EYShht+RpEnfL0Uw97R/2wsCWigNi2QruYzcPM5p7Fpcm9gwUuUY+zLcXSYgHZrAsBEAoJZufDGBo+/BIlEcHMbBi3b1q7e3wAwDCByWk2sqDedOHyOW+WnEuRiSgglqW4uVhALustJQ6FBMdPhBEfOnw2G4ZgejaE5Zt2RTabJtgAsoexoWHvYIFL1MNUFddfysMqeAmn8EJ18VoBZ++KIhw5/Ezu2HgI4YhgfdWGZSmGhw2MT4URDvM4AuodsWcfAlD8AeKZgAdDRANNVbFwNQ/L2qs+LUuxcK2AO+6KIdSG/EyOhxEOG1hftWHbXjZPTIXb8tzUfvc8f4mriXoIC1yiHpbNuL77bVSBzQ0b08cibfk6Q8NmW64IE7Xb+Ys2HjAe47IvIuoZmR3X2ydbpZTNUzPtuco6nDAxnGA2HwX3sbjtKSxwiXqYbdVvJmEVujgQoi7bXYZMRNRjbEv9N8gqdldc0eDg1dvewwKXqIfF4oZviIoA8aHWlilZlsJ1FJGotK0RBlG73fP8Jbz1MzfxxDPJoIdCROQrFvffHiQCxIdb2zpkWQrXVa+xFLP5yNnt4k89hQUuUYeo6qHDKlI80D2dciobTYSAsWRz/3xtS3FjIY98znsCMYDZ42GMjPGfP/WO3aXIj2cBsLglos5oRzZHYwaGEwZ20m5FNodCgtGx5pYUV2ezYQCz8xGecXvEvPUzN8HM6j38CZeozdLbDpZvW7AKCjMETE6FkJwIHThQj58IY2NdsLnuQF0gMWpgcjoMw9z/+VQVi9fyyOf3Elgd4OYNC+GogViMxw1QsDj7TUTdsL1lY/W210zRDAGT0yEkxw+ezXMnI9hYs7G54WXzSCmbjeayeeGlPAply5kdB1haKOD0HVFEmc1HwoXL57jaqEexwCXah6oite1gfdWGYyuGhk1MzYR8OxjvpBwsLRZ2Z3QdG1i5bcPVg7f2FxFMTIYxMdn64/M5rQjQElVgc83G7Hx7mlQRteqJBx/1fsPilogOQFWR2nKwvlbM5kQxm8O12ZxOObh1w6rM5ls24ALjh8nmqTAmDvD4XE4rOjCXqAIb6zZm55jNRwH7RPQuFrhE+1hbsbG+uncW3faWg3TKwZm7YjVH6awsV54nC3iBtb5iY2Ly4DPFB2XbChHUjAmAb7gSdRIbRxFRu9Rk86aXzWfvrD2mZ+W2fzavrtpIBpDNjsVsPup2J2mpJ7HApb5Vmt3d3PD2r44mjZaXI7mOVgTo7uddYH3VwrHjlbOs9bonuuo9xizbWqOq2Fy3sb7mwLEV8biB6dlw3eYVBxGLG74BKgIMJbgEirrj/EUbL7zjTbj/ydmgh0JEAVNVbG852NpwAAVGx02MJc2Wstmpl80OsL5mYWa2yWx2AHUBaZTNQ8VsbuOy4UbZPNxikyrqvvMX7aCHQPtggUt96+YNC+ntveZM+ZyL1LaLk6cjTQdpPl9/ljW749Z8LhyR3YYR5QzxGkiUW122sbG2F9CZjIvrV/Nt23/juorUlg3TBOzy92LxCu3kOP/5U+ftznLzHFsiAnBz0aponJjLuUhtOTjRUja7dbM545PNkYhU9KIoMUyv8WK5lduW1/OilM07Lq5/M48zd0YRibYpm7dtGKa3VHqXFBtIMpt73gvveBMzrcfxXxH1pVzOrShuAS8Ic1kXmbSL4Sa7FIbC4huggFfMVps+FsaN64WKx4h4zSzKg9t1tKK4LR/j2oqNuZOH239TamCRz2nlWAwgOW5iYioMs4kmVUQHceHyObzNegWeu8LmG0S0J5d1a04FUAWyWReZHRfDieayORxqLZunjoWxtFCbzVMzldnsOFpR3JaPcW3FxvETh8xmV3H9ah6FfG02jzObjwQ2RjwaWOBSX/K7ugp4S5F2dpymC9xwWBAfNpDdcWuCcWKq9p/PcMLE3MkIVm5ZKBQUoWKnxuoZWavB/ptczn/srUhtOzXFLQBAgfHJEEIhBii139NPPQwA7CpJRL4yO7XFI+Blc2bHab7AjRiIDxnIZNyKs+JF4NuQMTFiYu5EZPeEg1I2Jycq72sVGmRz9vDZvL3t1BS3AIrZHIbJbO55LG6PBha41JMcR7Fy20Jq24EAGB0zMTXT3NE4QHGvq6Ai+AAv/FqdHZ2eCWHxWgGOs/ccx46HEB/yD+LEiLnvOXaNrgxHfGafW7WTcv2fX7zlVmNJ7vGh9ijtr337k7PAlaBHQ0Sd5NiKleWybE6amGry2DoAMEPiW0CKAKFQa7k0NRPCjetV2TwXQnzI/3kSoyYSo4fI5ujhszndKJszDkZ5Pn1Pe/qph5lzRwT/JVHPUVVc+2a+oinE5oaDTMbF6TuiTe3RiQ8bNcVtyViy+b/2tqVYeKkAt2ridiftYmy89v6uq8jnFSETvscIlZimYGTMRGrL8VnOfLAjCyqev863KGi9wCeqZ3epFvciEfU911Vcu1qVzesOsjsuTjWZzUNDRr1oxshYc1dvAS+bF6/5ZHNKMeazgKTZbA6FBCOjJlLbncnmELP5SOO2m6ODBS71nHTKhW1XRqAqUChoU3t03OIeF79Z0pnZcM3xAY1srPvvk02nXBQKLiJlQbmxbmHllr07Ox2LC+ZORusuB56dC8MwgK1il+dwWDBzPFx39rkVyfGQ7z4iEWD4gN2TVRVWQeG6QDQmXT9WgXrH00897AU9l2oRDYx0yvHN5nxBkc24GBreJ5sdL5v9KtyZ4+GWts6sr1k1xa2XzQ6sgltRxG6sWlhZLs9mA/MnI3WXA8/OhWGYldl8bK49Jxwkx0O7z1tODGDogN2TVb3z7pXZ3FE8FuhoYYFLPSeXdaA+W13U9Toh71fgbm3YsK06t23aSE40/9c+l/VfTiQCFPKKSLHfxE7awcotrxgu3T+bUSwt5HHqbMz3uUUEx45HMDPr7ccRQduCKRI1MDsfxq0la3eltmkCJ041N8terZB3ceN6wTufT7yu0MfnI03vZab+sHvFlku0iAZOLuvWzeZcTjE03Pjxmxt2ZUf/Mtubdkud/XNZ/+vApWwOl7I55WBluTqbXSwtFHDybNT/OYzKbDaM9hWM0ZiBY3Nh3L5Zns3SUgfpcvliNtvl2Xwi0vReZmrOhcvngGeCHgW1ggUu9ZxIxIBI7QynYQDh8P4znDvp+o0gclmFqvoGST7nYmvThut4e3WGEwaiUUFmp/Z5VCs7Nfqdx1f6etWzydVEvD1J7TY6FkJixEQu68Iw5MAzu6qK6y/l944zUMABcGOhgDN3RSuuYlN/ij37kLfHlldsiQZWvWwWw7vKuZ+dtFP3tmym3sJlr/Hitk82ZzO1963O5jWf0woAr2uzZWnDcXcqm8eSIYyMtiebF67md/cg72bz9QLO3hVt+HMHNe/C5XO4/5l7gx4GtYgFLvWckTETK7etvTftIsMAEiP7v2HvtwTZL0g21y0s39oLwu1tB0NDBmZmQ9jcrLyiLALEhwxEy87Dc+z6s8m2DYTCiq0NGxvrDhxHMZwwMTUTaqpgPwzDkH2Xje0nk3ZrloIB3g8SWxs2po8d7tgE6k0Voc49tkQDb3TMxMqyBa3KZtNsNpsNeCVYrXr1XWnrz242bzkYThiYOhbC1mbtPtn4kFFxVm2jbHZsr5tyKZvdYjZPzoSbKtgPox3ZvJN24fp1pFZga9PB1AwL3Hb4f8/eFfQQ6AAC/dsvIpdFZFlEvlzndhGR94jIiyLyJRH5zm6PkbrPMASnzkYr9qIODRteE4smlgo1WoI86tM92HG0orgFSkcWuMjngZNnoojGvK8r4hUDO6xIAAAgAElEQVTg82Xn1Lqu1m3qpOrtiVm+5RXQhbzCsYHtTQfXvpGv2c/Ui2xH6zbsqrcUnI6ue56/hCcefJQz1gOM2Ux+DFNw+mwUsfheDg8NGzh1NtbUFcjxFrPZtrWiuAW8TN3ZcWEVitkc3cvm0TET86eqsrlODanwuiKXZ7Nte4XhtW/kjkY2242yuffHfxRcuHzOW71ER07QV3A/AOC9AD5Y5/aLAO4u/vouAP+u+H/qc5GogVNno3CL05OlPTCqCstSmKbsdhzcSTtYW7FhWYr4kIGp6RCOzYVwe6l2s8/2pgt1Czg2t3eYembH9T22QBVIbTmYOxnBmTtjcF2t2Sfr2MWOzz5hIgJMHwvBdeHbVMJxgY01q+eugOZzLpZvWchmXBiG90ODn8M0rKLes7u/lsuQidlMdUSiBk7fEWsqm9MpB2urNuxSNs/Uz+atDS+bZ46XZ7Pje9yful42Hz8RwZm7/LPZLmazX6EnAswcC8F1/LPZdYHNdRtTM4fvmtxOuZyLlVI2m8BInSOPRIAhZnNbcKL36Aq0wFXVT4vImQZ3eQOAD6qqAvisiCRF5Liq3uzKAClw5c0dNtctrNzem80dGTURi0vF51JbDnZSDk7fEcXLvjWEzU0byzcrwzSVcmBdc3HqbHR3j029uU7DKP997Qz12qoFy2+mV4C5k2EkRkLYSTv+B8crkN052CyrbSnW16xiYw/B+ES4LUcMWAUX16/md5ckO453RFMo7F2tLX0PIt7sd72ApaPj/EUbDxiPsbClXcxm2k95Hm6sW1gtz+YxE9GYVHxuN5vvjOLubw1hyy+btx0UCi5O3+E1ZhQRv/rWu22/bF626ha386fCGE6EsJPyz2ZVb+L7ICxLsb5qIZ9XDBezudkzghspFLO5tF3Ksb3inNncOeyafLQFfQV3P/MAFso+Xix+jiE6YNIpB7erwnB7y8H2Vu19XRdYXbYxdzICx0ZtgCmQzynyOUUsLl5r/jp15s6Og9S2UzcsUtuu72MF2N2jG25wcHzoABPE2YyD61cLex/vAGvLDmZmQ0hOhA7ViXl91fY9esEqeEcsbW/ZUNf7AWZ8MtTUknHqTbtXbIlax2wmAF5RWl2obm/677N1XWBt2cbxExFve0tV9arFbM7lXMRiBoYTRt3s3Ek7SKccJOp08k+n6je0ika9x4QaZHP4ANmc2XGw8FJlNq+2MZurO1j7ZfNo0jz01yLqB71e4Pr9C/V9OxKRRwA8AgDHwvFOjokCcHupsP+dymQzXrjlc42O+XERixswDIFhoKapFeDNjN5cLKAwHfI95L1RhpSKv0jUQCxuIJupnRHeSbvIZhzEh5qfbb1x3f+1WL5lY2vDwamz0QPPGOdy/rPWhuHtJT496X/kER0du7PSLG7p4JjNBKD1bM4UczCf958chgBWXhGLFY/OM1DT1ArwsnlpoYDJmRAmp/yyud61373cjsYMRGPie+RQOuUim3FbOpf+xkKDbN4sZvMBJ4Vz2QbZHGc2txuv3h59vb5IfxHAybKPTwBY8rujqr5fVV+lqq9Kmr21p5EOJ5d1656dV0+pk3JsyPAtQr3mT0bx9+pb3Jbfd23FhuvUhmBywvR9/lhMKg6tnz8VQXyo9o6uCyxeK+zuZwK8wnvhpRxe/FoW16/md4t1wGuI1WishYJifa3FF6tMeWfoctVHL9DRcuHyOTzx4KMMbWoXZjMhm3Eb5pGfUjbH4/7ZDAUisdK+XsDdL5uX7Yr8LKmbzXEDZlk2nzgVbZDN+YrnzucaZLOtDcdayCs2OpTNkQ6fxjBoLlw+F/QQqA16/V/FFQBvLnZsfA2ALe7xGQyO4+0xvXWjgNs395khrsomEWCiOKObTIYq9tGWbo8PGbsFbulzDb+EALl87Qzq+IR31mxpplkMrxA8frLyAHnTbHwkQGk5VWrbwdUX88jseN2WsxkX168WsLVhNTVOVW/p9kGNT4VqvkapmVSnjzSi9jt/0Ubs2YfYKIPajdk8oBzH22PaTDb7ZcnklLdwcGw8VLGPtnT70PDeEXxe46jG4xHxljVXG58MYXjEqMnmuROVkyxmSOpepVV4q6wAL5tf+oZPNm9aZfeu77DZPFEnmxMj5r5HI1LzeOZt/wh0ibKI/CGA+wBMicgigHcBCAOAqr4PwMcBPADgRQAZAD8VzEipXRxHkSt2AIzFDd99IoX8XqOjevtjSkbHBKqGVyCKV+tOzYR298yaIcHpO6JYvmVhJ13sCpw0K7ojigjGp0ysr9QPH1VUXJEtf+zcyQjyeRe5rItw2AtLv++r3nl8pVlqVcXNRf8fGG4t2RhNhnaXU/udS7s3pvq37ScaNXDiTAS3lywU8l5nyrGkienZ3uomSfvbvVrLM2ypRczmwbOXzYJYXOpm87Vio6N9szkpULcqm4+FdvfMhorZvFKWzWPjZsVWIBFBcsLExtp+2Vz7eRHB/Mloc9lc7+kVcB3dP5vHQjBDhreculPZHDNw4nQEt2+WZfO4ieljzOZ2epv1iqCHQG0SdBflH9vndgXw810aDnVY6cD2Utdi0wBOnInWLL25fdNqetnT9GwUoZB4S3dtRSgsNXtcwhED86eidZ7BMzkVwsZq7XEBJbG4gUik/hXMaNSou4SoJDFi1hxMXzI0bKCQ14Y/NBTyimhMcPxEpO4+XBEgOX647olDQybO3mX6Hr1AvY2zz9QOzObBsrFqYWW5LJtNwcnTEUSqMu3WktVwGW65mdkoTHMvm8NhqWlKGGkim6dmQthcr5/N8biBcBuyebtBNudzDbJZva1B0ajg+HwES3X24ZYK0sMYGmY2d9LTTz2M564kgx4GtQnXHFJXZDPu7oHtruvNcto2sPhSHlqWHKraVHv+0hmzpauqpimIRI0DN3AwDAPTx2qXAAFec6X5k4ffOzaUMDA0XLnvqBR6kWid/UjlYyw2jkqMmDh9RwSxeOUDSmffJSfaM29lGP6z+NSbnn7qYRa3RNSSTMbBynJVNluKhWuFmmz2a5RYTQSYmQ3tHltXyuaDdtw3DO/83HrZPHfq8Nk8nDCKV3f3PicCjE+YCEf2z2az+L2NjHrZHPXJ5uGEgeQ4s7mXsbjtL73eRZn6xOa67TsD6rpe8VuxP7VO80MRYHjEhGl4+3da6W7YjPFJ77y6tRXvYPpwRDA1HcbIWHvOkxMRzJ+KILXtYHvTKV5tDe0eyB6OCEzTf7lUKOwdN1QSi5s4fYcJdRXptAvbVsTjXrdmGgznL9r4pTe+eS+UrwQ7HiI6ejbX/K9cuo4il1XfBkzVvGw2YJqC5Hio7Tk0MeWd87626mVzJCKYnAm37axXEcGJ0xGkthxsbzkQw8vm4YT3/JFo/WyORKRiD2wsbuIMs/nIYQPG/sMCl7rC8elAXFK+n1TEO6A8VdWMQcTbOzs7tzdbWwoQx9aaplEHNZYMYSx5sH8Wtu3NcBsGildq/ffsjo6FMDpW+zVKIXv9aqHiBw7DAE6d9V/GJQYPdB9EsWcfwgNPzrKoJaJDaZjNZbd52Wx4Z7+XKa1COnZ8L5tdV7HT7mweD2HsgFdAm87mZAijPvkvIpg/HcGCTzafOON/BZnZfHTEnn2IvSr6EAtc6orEqInMTu2ZtKqouRJ77HgYhZyLgqW7V3KjUcFMWTOFfN7FwtU8XMXufRIjJo6fCAeydGdt1cJacQ8T4IX+iTNRxFoM9ljcxF3fEsP2poNczsXQkOEbuDSY2DiKiNopMeqd0e6XzbGabI4gn8/DKs/mmFQ0OvKO0slDda8R1cioidn5gLJ5xcLaSmU2nzwTbbnojldn87DhO1FNR8v5i7Y3WUx9h/86qSNUtSLMRkYNrK8CVln/BRFgcmZvr06JaQpO3xlFNuOikFdEYlI8M092n/vG9ULNcqF0ysH2pnHgWd6DymQcrBX3MJX/kLD4Uh53vjzWcqgbhrRtHy0dfecv2njhHW/C2xnCRHRI1dk8OmZiY9WGZe3dp9TjoiabQ4IzZdkcjRkVHZfrZXNq28FQwjjw6qiDyuw4WFvxyeZredzxMmYzAQ8YjwU9BOoQ/kultkqnHCzfsmAVFKbpnd2WnDBx84ZVUdwCXnfE0nm1jqNIbztwXa9RUjRqYGjYxNBw7dewCgrbql1Wpert9e12gVuvw6OrPvuLiVqwuxSZV2yJ6BDS2w6Wb+9l8+R0CGPjJm4uWhXFLeBl8/hkbTYPJwxEGmRzIa+wfY7D87LZ6XqBWy+bHRfIZV3Eh5jNg+ye5y8Bj2eDHgZ1CAtcapudtIOlhb09Ko4DrC7byGZcZNK13RfXVmyMT4aQ2XErj7257e3pmZn1X9KkirqNqPY7m68T3Dp7mASNz6ttRqlzZWkp90G7RNPRsntcAQtbIjqknbSDpcXKbF65bSOz4/qeWrC26p/NK7eB5ISJmVn/faeNs7n74Vxvf7EATR93VE95V+l4/OBdoikY9zx/CfexuO1rLHCpbVaXLd99POlU/Sovk3awtFj7uK0NB4kRc7eLYblIVGAIUJ1PImhbx+NWjIw1v7+4FZkdBzcWChU/LBw/EUFihLPO/Wo3dNk8iojaZPV2i9mspfypfdzmuoPEiOO7Mikaq5/NowFlc739xYfO5qqz6OdORnx/XqHexOK2/7FvObVNodD6DG0u7/8YVa/I9SMimDsZKR50Xvyc4RW+45Pdn7MZHTURjUnNGXrTs7V7mJrlOIrF6wW4jncVuPRraaHguzy7WyzLxU7agWUd8tI0VXj6qYfxxIOPMnSJqO0OlM05hV967ZfNx0942Yyypk7RaDB7V0fH/LN5Zja0e658qxxHsXitUJHLrgvcuF7wXZ7dLVahlM3BjeGo4JFAg4FXcKltohFBNlv75iriv3RYxDtDrp5Gb9NDwybuuDuGrU0blqUYTphIjPi3/+80MQSnzkaR2nKQ2nZghg5/FmB626n7Amxv2bt7lw/DcRSFvItQWBAONx6ruoqbNyykU87un2dixMTx+TCXZh1QRfMoXrElog6JRAW5FrM5HJa6Gdwom4cTJs7eHcN2D2SzYQhOnYlie9tBuk3ZXH2EYfVt7Zhk38tmA+Fw49fNdRU3FwvYSbuV2RzQiRK97umnHmbeDggWuNQ2U8fCWLxWeU6cCDAxZcIqeJ0UVbE7uzt3KoJY1ICqVfNcYuy/pCkUFkxOH77QA7z9NJkdF5m0A8P0zsPbL1jKNTpD7yAcx/8HD9XG5xY2Q1WxetvCxvpesRoKAfFhAyOjIQwnan8YWVn2itvybpTplIPVZWC6zn4sqo/No4ioW6ZmwrhxvTabJ6dN5PPehGopm0WA+VNRRKIC+GVzE8uNwx3M5rFkCKFWstmQQ51vX81xtaPZvHLbwmYr2Xzbwk7a9cnmyuObyPPclWTQQ6AuYYFLbTM0bGL+VATLtywU8gozBExOhZCcCEFEMJ51kdlxYJqCxKgJ0xSoKsYnTayv7s2KigCJ4qxvN5SONijtoxXxGmDNnQxuv+tQwoAs1xa5Ijj0Pp+tTRsb65XFqmUB1qaL1FYB8SHDm/2FwAx5Ybq1UduNUhXY3HAwzdNrmsZzbImo24YTJuZORrByy0KhoAiFgInpEJLjXjbnyrJ5ZNSEUcrmCRPra1XZPGpiONHlbM64UHcvm+dPBbffdXjYxJrYdbL5cK/L5oa92/m5Jpu3C4jHK7NZVRtks80CtwqXJg8WFrhUw3UV+ZzCMIFotLU37OGEibN3+QdPLG5ULA1SVdxc9K4MlktOmJg+1r3lNaktp6JJVOn/NxcLuPPlsY52Li7kXaS2HUCAkVETkYj3+sRiBkbHTGxv7YWXiFf4HqY5BgBsrPkfnQB433tmx8U3vpYHinunjs9H6naDPmyX6EFw/qKNoXf/IvfXEtGhlLLZNIFIi9mcGDHrTtj6ZfPSgrfstVxy0sT0TPeyebtONi8tFHDXt7R+jm0r8nkX6W1nt6jfzea4gZFRc3dFGlAsbkeMQy19BvbJZrc2m2fnwnXvf9gu0f3m/EU76CFQl7HAJQDeUTdrq96yVXUBiNcjIhwRnDgVQTjS/hnbnbS7u+y13Oa6g8npMMwuTdCWF5HVctnOnWO7tmLtHkIPAGvLNqZnQhgv7q89NhfG8IiJrQ3vjXk0aWJk1Dx0qDvNNsJQIJ9TXL+aRywmyOVqHxeLc49PI+cv2t5B8ixuiegAHEexvmJhY6MymyMRwfzpyL79Ew4inXJ3l72W21xzMDnVxWzerJ/NnTxjfnXZwvrqXjavLtuYng1hfMLL5tn5MBKje9k8lgwhMXr4fcZNL3EuZvPCtQKiMUHeJ5sPOxHeT3ZzmAYKC1yCqlfE5Ms7GqvXSKKQ995Ez94VbftsaapOYSkCZNJuIEf+lGt2N00h72Jzw4ZtebO4I6Pmvld983m3orgFvNnplWUbiVET4YgXliOjXlHbTkPD3uxzs1SBeMJEvmB7P2AViQEcO96Z/be27TXZiESMlvZb9RIuhyKiw1DXy+aCTzbn84rFlwo408VshnhXEdudSQfRzLe8m802kEh42bxfU8R8zq0oboFiNt+ykRjxenN0LJuHjIbHKlZTFxgeNlDIV/55iQHMHO/M8mTbUhQKRyebWdwOLha4hHTKRaFBa3nbVuSyivhQe9/MGgZUF983x8ZDyOwUagJdZP9Z0HTKwdLC3mPTKQcbazZOnY02LHLr/gAB789jfLJzs69Tx0LYSTtNLy9W9f5z5s4o1ldt5HMuojEDE1Oh3WVb7aKquLVkIbV1NLs1X7h8Dm+zXsFGFkR0aKmUA6vBET+W5S1ZbvdKmkbZ3M3GvMnxELIZ/2zebznw9paNWzf2zvFNbztYbyabtxtls4PxDh53NH0sjMxOvrVsFnjZvOZlcyxuYGIy1PZVd6qKWzcspLarsrnHuzW/8I43sefFgGKBS8hmnIorc9UE+y+dKeRd5POKSFSa3rc7Nm76Lg9WHL5ZQysSI3v7XXcJMH8q0vCN29tDXKiZ6S3kFZvr7TnKpxMMQ2CYze+fLf0wEYkYmJ3rbMfktRV7t/gvnzRYuQ3MdOhqcbtcuHwO9z9zb9DDIKI+kd2pXSZcTmT/LSf5vIvCAbLZr9ATAEPDXczmUQMjaXPvaJ7i8uz5U42vWruu4vaS5Z/NGzYmJvskmw0gFjcRiXY+m1eX7d2/EzUnKRzrzWyOPfuQdwwfDSQWuIRQWOqehwd4n683W+q6XjOKzM7eGWzxIQPzpyL7LtOND5mYmAphfbW4+V8AKDB/cv/HtpOIYHY+gvFJF5kdF4YJjIyY+x4E77cnFfBeg9VlG7mcYnIqhGis9rUbHTNrlkGVJEbb+wNEIe9ic91GoaAYGjaQTjuwa09/wNCwwHG8HwJ2xyXe34+RLnWT3lyvfU32ujVrz84UP/Hgo8AzQY+CiPpJOHK4bL5xvYBspvVsHho2MT4ZwsZaWTYDTT22nUS8Jofjky6yLWRzPudfIaoCq7dt5LOKiemQb8E/Mlo/m9udg4W8i411G1ZBMZQwkN72z+bhYYFdlc2ls4q7ddpE3WxedzB9rCtDaMk9z19iY8cBxwKXMDYWwtqy/xu6d45tCKGQf6Cs3rZ2uxyWHp/NuFi+ZTU1ozg1E8ZY0sRO2oVheEte9guvVliFUtEqGE4YDcM5GjN8i9F6jH1+8EhteYfLnzwTrVnqHIkamJwpvu7YW5E9PRtqa9OQnbRTcf5hpsEVgXxeccfdMayt2F5zDyhGR01MznRvebBTZ2two6sYQeIMMRF1ymgyVNOroaSUzWadbF65bSGTcb09u2XZvHLbaqp3wvSxMMbGTWR6IJtjMQOxFrJZDGmYzdtbDlLbDk6ejSJeNUEQjRmYnC6+7tjL5pnZ1s7f3U9r2QycvTuKtRWrmM3eJPnkdPeWBzc6SUG19yafWdwSC1yCGRKcPBPFzcUCCsX9PiJANC6YnAo3PAt2y6fLoarX/XB2rrmvH44YSE60fxZy5VYBG+texVR67z1xpjbQDioSFYTC0nCPlCpw+2YBZ+6M1dw2ORXGyKiJ9LYDiGBkxGjrvhlvz0ztEupGYzUM73D4oM7Piw8ZyGZqkzQak54L0CcefJR7e4ioY0LFbF5aLOzmjLdlRDCxXzZvODWdElW9zD52vLmvH4kYiLQ5m1UVK7ctbFZl88kz0UMfs1MSjQpCIYHVoLeIKrB8s4DTd/hk83Qxm1MORASJUaOtE8+qipstZbMWszkS2NXSWFyQy/qcpNCr2UwDjwUuAfCWOZ29OwbLUoig7hXbavVm9bwrusHN6u2kHe/Io6rz825cy+POl7fn/DwR7wil6y95TSHq7WP2a+FfEokYmJjqzBIjy9K6V0T9dGsZciMzs2Fcfylf2a1ZgGMd6gh5UAxQIuqGWNzA2buisG00nc2qWv8KZsBnl++kXWz6ZPPi9TzufFn7snn+dAQL+2SzX8FWEokamGjxrOFmWQVt6ZzaRA90rT52PILrV/OV3ZoFmOnw3t9WxZ59iBPPBIAFLlUJt7gEZ2jYQGanNj3iQ4c/E+4wNjf8l3W52t7z8yJRA3e+LIbMjlux3KicEdBxdPvtlSrtyxIBTBOYCuiqbblY3Njt1pzLuojFDIxP+e+VCgKXJBNRt4kIwi28PYtI3dUw3WwS5WerXja73rnz8aH2ZHO0mM07aQdLC5bv1+zWeb7VWsrmkLeVK2i72by2l80TUyFEeiSbS5jPVMIClw5l5ngY17+Z39uDK97e1GavuOVyLrY3bGSzXiOMoWETyYn6e36bVW/GVtD+/ZwiguHEXlOO6hnO8clg/pmFQoJYvPaHHBFgctobU6HgHTExlgy1rXmIqmJjzcbmugNXFYmEiamZcNP7l7rRrfkgWNwS0VFx7HgY16/m4SqAsmyemW0ym7Mutja9YkYEGB42MdaGbK636ksa3HZQIoLESAjjky421pyabE4Glc1hQTRWu+RXxDvGT10vm+ND3gkPHcvmkWI2N/ln2o1uzYfBlVVUjgUuHUo0auDsXTFsrJfORxWMTzRXzKzctmoKwmzGxsaajdN3RA81MzgyZvo2bSh1kuyEqZkQHFuxXTzDVSIh3PkT/wAXfucijND+X/Mz/+A32z6muRMRLFzLe/u3il2qR8e87tWdusJ+Y6GAnbLD6rc2HaTTDs7eFYPZxiYl3cTiloiOkmisOpsNjE801yip1L+iOpvX25DNo2MmshmfbEYnszkM20bF+eqjSROTU8H9CDx/MoqFl/KwbN2deB9Nmhif6GA2Xy9gJ12WzRsOdlIOzhzhbC5hcUvVWODSoYXC0nJTolzOrSluS1wXuH3Twskz0QOPaXTMxPamUxGkIsCxuXDHjjn48Pv/Rzx3JYloNovE5hbSyTHk43Hgf8s39wTFN+hnf/Cv8bc//aW2jCkUFpy5M4pcVmHbilhM2n4AfLmdHaeiuC1xbG9pWq+eDdwIi1siOooOlM1Zt6a4LXFdYPmWhROnD5HNSRNbmw5yOXd3pZUIMNvBbC4dNzR9TGFZikhYYIYETz/1MJ67kvR9zCt/YBM/8pb/0JHxAMVsvquL2Zx2KorbEtsGtjZ792zgZnDfLflhgUuBSPscIl/Ob19vK0QEJ05HsJNykU45MEwgOd7e/SLnL3pnBD5gPOZ94or3v3w87hW2B3T/M/cCD96Lj7vvwRc/cfh/ot5+rPb/4GDbitSWA8fxzvCLxw2sLfsc4le0k3aOXIHL4paIBklq23/iuaQd2XzyTATplIudlAPTBMbanM0lpYwGgKF3/2Lt0TFX6j/2uStJPFd2VbBdeVyuY9lsKVLbXjYPJwzE4gZWG2RzJu0c2QL3wuVzuJ8ZTT5Y4FJPakdjJq+9v9n2DoTnL9p44R1vwgMdflN9wHgMeBD4Vx/7tx39OgdROsMP8JZWra8CwwmjYcfocORoLYFicUtEVEnalM0joyZGOtAdOPbsQ7u/r8joQ56LWsrj3/qFW8jd/yeHeq5OSqccLC1UZnNixEQh3z/ZXHLh8jnvggCRDxa4FIjRMRPrq/VniseSwbfF9/PO174FI8tZhB9zMDqcQSoZg5qd7SL4xIOP4lP/Ot6RPboHoa5iaaH2DL+dtNtwYiI5cXTebljcEtEgGh0L1TRkKpfs0Wx+12sfQWIjh/BjDrLDYaSTMaADQ337k7PAg4+2dStRu7iu4uZibTanU07jbB4/Otlc7m3WK4IeAvWwQPt7i8jrRORrIvKiiDzuc/t9IrIlIl8s/npnEOOk+lQVmR0HmYwDbaE9cSRqYGomBL9eCkMJoyeOrCm5cPkcnn7qYfzL7/lZHH9pEyObecQzNsZWs5i7ugnD7vzBgvc9nsU9z1/q+NdpRF3F1qaNhWt5326XqoBhwvfPND4kiMV68wejagcubtvdnpsoIMzmo6+UzdkWszkaMzBZJ5uHEwYme+DImpJ7nr+EJx58FL/6PT+L2Ze2drM52YVsvv+Ze3Hh8rmOPX8r3ENk89CwIHpEsrlco/3TNZjNAymwaRsRMQH8DoD/AcAigM+JyBVV/W9Vd/0rVX191wdI+/LOlyuUTiCACDB3MtL0GbMTU2GMjJpIp1zYtiIc8c7u65UzTwHvTfSJZ5KAKuZvbsAoe580FBBbMbaawcZsouNjue/xLD71/KVAruS6ruL61TwKeW2YFeGwYDhhYGtjr1tlLC6YOxlBNuMinbJhmoLRsea6eXZby8Wtqxhf2UFiMw9RIB8PYf3YMKzY0ZwRJ2I2H32lbC4RAeZORTDU5Bmzk1NhjPZoNseefQi/9/WYV9w8ngVUMXkz7ZvNo2tZbB4b7thYSv0ygtxG1Gw2RyKCoWED25tl2TwkmDsRQTbjIJ1yYJresUS9mM3lmiluxVUkl3eQ2CrL5tlhWFFm86AI8k/61QBeVNVvAoCI/BGAN/kyEnkAACAASURBVACoDlHqQbatuHF9bylM6X118XoBd76s+Zbz4YiB8cngQ9PPEw8+utuEwrRcGG5tegiAobSFjS6NKagid2vT3jdARYDkhDdpMTmtyOdchMOCcERw84a121hMBFhdtnH8RBgjo70TNvc8f6m2Cck+pm+kEMtYuz9cRbM2Zq9vYelsEk746M2KE4HZfKTZVmU2lyxeO9rZvLvfsqpbbshyIXWzudDRArfkiQcfDazI3dxoMpvHw0iMmpiaVuTzZdm8aCGdKmWzg9VlC3MnI0iM9GZ+xZ59CM89uf+V2+nFFKLZqmy+tl3M5t75e02dE+Sf8jyAhbKPF4ufq3ZBRJ4TkU+IyLd3Z2i0n9SW43+DAqntOrftw3UVmxs2rn0zh5e+kcPaitXS0qp2KS17KqeGoN6PBW6Xz48LYrlyaqv23MJyIsDIqInEiPeWEgoJhhMmIlHD62Rd1jVb1ft1c9GC6/ODyWGpKtIpBzeu53Hjeh6p7f2X6J2/aLdc3IYKTkVxCxRXMrjAyEbuACMn6gnM5iNsu0E2pw+RzRvrVmDZfM/zl+o2E3IbZXOHjh3yE9Q5rOkmsnl0zMRwKZvDe9mcLp4yUZ3NS4uFzmXzdmvZXK2ZFVahvF1R3AJeNsNVJDaZzYMiyMsnfu881X/TvwDgtKqmReQBAB8FcLfvk4k8AuARADgWPvgRLdSY6yp2Ui520v5NKFQBx279jVFVcf1qDvmy9558zsbaqo0zhzxYvhVPPPiob7dFN2QgFw8hlrEr/uK6AqSSsa6MrVy3r+SadSZzRYDRcRPJZAixuP+f0daWfzMxEe/IiXbPFN9esrC9tff3cyddQGLExPETYYjfJiSUHfXUgnDegQpq3rUEQCRn+z2E6ChgNh9Be9ns/36rCjjOAbLZVVz/Zg75suPc8zkb66s2Tt8ZRaSDZ7cC9TO5xA0ZyMdCiGZ9snmiu3/fgriSazTI5rFxE2MNsnl7s042A8hmXAwn2pvNt5YspKqzedTE3IlIU49vdhIhXHC8b6LqezPAbB4kQV7BXQRwsuzjEwCWyu+gqtuqmi7+/uMAwiIy5fdkqvp+VX2Vqr4qaTb3j4Vak8u5+MbXc7i5VPA9MLwkn3Px0jdyWFooIJf9/9l70xhJ0vQw7/niyIi8M+vu6rtnhqRoajQ6qVkvDK71RzMjgMJApsg1LVu0RItreUlwbZle+48Nm7CEFSHLkMyVgYFlwRYX8AjQwqJMUPLIgkAKOiztrmTsknP03XVX5R335x9fZlYeEZlZWZVVWd3xAI2ZzsrKjDw6nni/7z0ipFSrvw8/Uau/RwfjO3eNejgU3PaQkUp7vgymnTwPtot4lk4kINSUQFtli2Zl/qH35+Gid3KllLSaYX9+3iCVlfimI7oBm1tmokABktfXLx7HiYaCWzjtIul04r+z8668+5aOiLk4iAAvrcFNub6kbr5mOJ2IT76n3NxuJQexTmeKmw995Iib6/VwKLjtEUX0R8Utgq++96WZz837N4v4A26WApoVi1bp8r9vi9jJldHZ3WwYgo0pbk58vnkPdAJOJxoKbqHr5npIJ8HN8+Jn9NgXkbr51eIqP+l/CrwhhLgPPAN+HPji4B2EEFvArpRSCiH+ACogP7z0I01BSsnzxx7RDBlOjbo6WbmOalxg2QLXOa0ROXADmo2Q2/es/o5as558gvN9iedGC93F/ep7XwIpKR10KJ44CAmdgsnJeq5fSxkZGjv3yphuiOFHeLY+XmcpJRknwPRCfMtY+Mn0R36hwy9ewON0OhFPH7mqDgclnvUtg+qK6piZL+isrBkcHQQguqm4Gty6YyXuivYoV/ShNKhBcvmL/UzbEzILmo2Q7EiTlbc/eBM+nO+5goyOkzexW6epUBJAEzSql7+rn5JyQaRuvkZIKXn2OL577iiDbm7UlZsH6zcPdgOa9Yjb9zIDbk6WvudJPC+68F3csSAxkpQPOxQG3byRJzTU80aGxot7ZTJuiO5HeLYxXmcpJVYnwPAX7+aL3MnttCOePnZBdv0iYWPLoNJ1c6GoU101OD48dbOmwc27melurhq0muP12gLI5S72M52U9dduhmSnBOJnWTgILAM3aw6lKffc3Ezd/MpwZQGulDIQQvxZ4NdQ08o+kFL+ayHEn+n+/JeBPwb8jBAiADrAj8urKMpMwXMlQULqsaaBndWIIonTGb6PlMTf5khazdP0VH3CN1HATPKel96Jc/1ZYyhYydc9si2fZw8qp7NuhcC3DXxLYrd8SkcOoS5olW0iDTYf11V6TBfPNti7XUIusBbovDKVkeTpI7e/eNH7tPZ3ArJZvb8CvLZhUqkadNoRmq6C02kCBTX2qVTRqZ+cNpkC1XFbu+D3RdNFv0PkIEKAHjOv+LxD4ve3i1T22xRrDiICJ2twvJVPG0ylXFtSN18vXEcSJvhxkpt7vzuI8nVEu3WanqobyedogcqyukjiApnRZn75uofd8nn+oIrs9cAQQgWtliTb8rGPfEJDuVkK2Bhxs5s12L+1ODdfRJAb9dw88h7v7QRkczqWrZy2vmlSXTm7m/MF1TW5l/U06GZxiW6edh0wz674/q0ilf1uF+UInJyacNBbFEl5+REvo5N+IFuRH7x+vgvXlw0pJceHAbVukFGuqFW/WQMMpxPx+KEbKzPLFtx7zebj73YIz9DDIl/UMHSBYQiyOcHTx37s/TQdXv9+e6YT9lnpnThNN2DrYW2oKQGoNOST9dxwLY+UbD6pk+kEaFLdB5QwrXYwlPcfCWhWbI4voZPjvDJtNkJePPViFxHKVZ2t7eQ0r047Ym/Hw+lIdB2qqwYra0bsZ+U6qnZb0wTFkj7xwmmQMJTUjgOcjsSyBeWqgZHwu54X8dnH7nhdrIAHb9hD4w8W3RTEcENKRx0yboBrG9RXs9MD3975eAHf9ZT5+X/+/Hv/XEr5+676OK47qZvHkZHk+CigdhwiObubO+2IJ4/i3WxnBXcf2Pz2dzszZV/1KBQ19K6b7ZzgWYKbdR1eu0A3x52TTSdg61G8m4/XczQH3Rx13ewMu9lLqtGt2pxsLNbN5wlyG/WQnWfxbq6u6GzcmOTmkL0XPo6j3LyyalBNcLPjRLR7bi7rM3faDgM1f7fn5krVSPS650Z89kmCm7/PTnT6PNMNpmG6AaVDB9NL3XzdmeTmNBn9FUBKydNHHp32abe9w/2ARj3k7oPpKaagglhNwKgjhYBS5XSl9yxNLFqN07O2aoigUTsePpMLATduJqfaeG5EFKnjO6tkB2VqOglNCSRYbX8owC2cOP3gtncfYKwBVe9n+Zq7uABXSnIND7vt89//8H/Af/LPfoV8eLYugVEkE2tuJl0UuU7Ek4du/zsVhup7FQSSzRjxWrbWX3GeFc+LePypWsFWacZwdBBw54E1NpOxd984gW7fzgwFt/ZH74+Nm7hIrLbPxpM6QvaaToUUT1waZYvjrfyYJEUkqe61yPdm9tndmX1pvVBKykuLlJKnj8fd3GyE3Lk/m5vtbHdnbOT2XvdcAF0XRGdwc7MZ9R9QjZjROIlz862Lc3PSgmPGjW8KpEmwOj5NRtzsjLt5NLjt/axQcxcX4EaSfMPja7/3T/CHPvknfH/jIbkLdPOkzQSnE/HkoTfk5oP9gCCUbGyNu9m2New53PzoU7WwMujmuzFNQT0v4tFnE9x8icGt1fLZeBrj5oqlrtPi3LzbIl9PZ91fN9K9+lcApyOHBArqhOR5cijInIQQoiuz03//QqO/agdQXdXnXtySUo2iee37MlRXdXJ5jeqqzr3XrNguu74X8fBjh4efuDx+6PLxd50zjScalWmQ0WKbEkgg2/IxBlKb8nVvbDV5EmJBWRIilNz4rMbqiybFE5fyYYdfufMuL+zYXi+J5PLxDRmEgGI5eVXzcH+8A6OUUDseb4QxL3svfMLwdPFUSpWuvvt8fEehd99Rsjkx9B16651gplED52Flp4kmT9vRiu6fYs1lZac1dv/1pw3yNbf/O5aj5unq/nxjPVJSUpafTjui0xl3s+vKiY0cBxFCsN11c++EI4QKfOd288jx1OsRD0bd/LoV22VXZdEMuPl7Ds3G5PPYpGyaIGFnLc7Nhbp7NjcvYBQOgAgjbjyssbKj3PyP134Xv3LnXXat1TM9Tn6Sm0uT3OzHuvnkKDzTQsckdl/4RHFufjHu5t3nfuxi+aibR/nZ33hxIcfaR0pWk9x84rKyG+fmOvn6gJs7AVuP6+jBAuvmUi6ENMB9BRgNbnvICNrt2S+g8wWdB2/YrK4bVFZ0tm9muHPf6qdSlSsG1RW9W1NB/LCJKfi+YGMrw+17FhtbmdjGUlJKnjz0cLvNMWSkTqwvnnq47vSTTpxMPdvAz+jjq+CAkLDxpN4/k8sJr2v09yXQyZtTj2keSkcdDD8cWq0ONJP/e+MPnqkLomEIVteHOzEKAdmc1p9rG4fjxL/XQqjGYBdBuxX/HOo7PfwcSReEo11Fv/vnfuxCji0JEUlML+G9oXsRNiBHww0TZval83RTUl5mnE4Um1osI5ViOiv5gs79N2zWem6+rRzaq6OsVNXtfTefFQlhMOLmmMZSUkqefOb2G1fJSGUBPX/i4SW4eVqpiJs1CMx4N2uRCkD6zz8hio91c2ExXZbLh+Nu9jWTv795RjebyW7OT3DzaG314O9emJsTfTvsZinlBI8nH8s3vv5FvvXNyvkOcgQRSQw/2c35mos2UNBuOgHWQLZe735EkkLq5qUn3WN/BTBMtds6KlIhwBztNDj1sQSr6/EBmxCC9a0MK2tSBZoCnj4c79CXhGS28oZOOyKIWYVUK5RBbHpsj0SZCsHenRI3Pj3BGHlsAehB1O+M3KzYWJ3m2Erx6KFLINLFwtKT8wmr1fVMnrpRoBw0J/6+lJIwVHVUq+smubzGyXFIFEmKJZ1iSZ+YWmZZAt+L/xxMc47VjRjimlKoH8x+38GXYH/0/sJ3b6VQf+JGCKmfCww/xOs2uzC9+Hm66cy+lJSXG8MQF+Zmc4qbN7YyrPbcDDx9dAY3y9nc3G5FsQ2vpIST42AsPXamPghCsHunxPanJ+jRuJsNP8JwQwJLp1mxyTjDbpZMcPNGbvrzz0GuEZ/l5WRsmkaOYtCe+Pujbs7mNWpHIZGUlEoGhdLkJlIZS8QGslIyVKpzHmbx7bT7TtoEuejgFlANxWJcO3g8hh/h6aduTufpXl/SAPcVoFDU0YQfXz87IQV1XnRDkDPU4xZKOs36cHv4pJOdrgssO/6MF0WSKFIn/HDCeWXS6uQ0mUa6RmhqGHF5ruI0naldzJBtZsg11AzAXiATJ9Gd28WFddSd1P3xd/6Ix+O/l/B7UnK4H3B0GED3wmV13aC6anAjN/uxrq6btJru2GdbqszepGIapYqumq8MfqwCSjHBd6msU6uFwzIaSbNedHCrnlPQKlmqe2Pcj6UcSrubNE/XzY5fsObqLuWDDkYQ4do6J+t5vOz0U7mIJLm6S8YJ8DM6rbJ12h08JSXl0imUdMSOH1s/O6k8ZF6G3FwcH9+W5GbDEGSsGdwcysTg4Tw7h5GhEZgauhvvZq170K1SBruZIdccdvMoEnhxp7y4bvcJ+nMxePMLHp/9esJxxbh5bd2gumaSO4ubN0zarXE3l6sX6+beZITB5yiVh90shKBQ0mnUhj+7SdefC2sAKQStoqXqaeN+LiEYWFjyrIR5ukJlFowy7GaDk43cTOOoUjcvhvQdfAXQNMHt+xYZS/RraE1TcOueNXMn23m5cdNkdd3AMFRqVKGocfe1DOWq3j8WoSk53roz3rAiCiXPn3h8/F2HT3/L4dPfdolkvESFUG3v4/jcd74y0/G2ila/8+LIo5+eqITgcLvIzr0yJxs5AkPEniylJtAXWKbRKI8fq0TNZ/1J60/x1jvxKwFHBwFHB0G/OUQUwcFeQO34bCuSdlbj1t1M/8JH01QX5c0bF5eSvb6pBtX3vidCgG0JNmKeY33LxLJE/35CU7vMG1vqvrN+By6C4808Ts4Y+5pGApoli2hgVEFvnu7gZykhdmZf4bjD6osmGS9EiyR2O2DzcW3qarIWRGx/esLKbovSiUt1v83NT04w4i4YU1JSLgVNE9y5N+LmjOD2PevCApEkbtwyWV0z0EfdXBl3880YN4eh5NkTd8jNSTvCQkBhpF73rEFMu5iJdbNEqECk+0SHN4vs3C2rGfYJbkYT6AucPdio2LFu9i2dn8j8dOLvxbl5fw43Z7MaN+9kyGRO3byyZvRdeBFsbJr9Bmc951q2iH2OzRsjbhZdN2+O39f+6P0LO8Y4jrbyONl4N7fKFtFAYBlYBm5u3M1SCJqVETcfjbrZZ/NRDXMmNx+Pu9lL3Xxe0h3cVwTL0rj/uo3vRUhUgLuIsTujCKHSpkZTp7a2dVZWI9rtCF0XFApa7Ny1Z0+GO0wGvmT3uU+xqNFonN4uhEq9KVfiv9KzduJrVm0KdRfDU/Uz6mQGhzGdb33LwLcMDDfEOBlfEdQiie6HVPY8AlOnXcoMnTzPS7NqY7cDsi21Wo2ASBPs3ywC3VrTv/u3xn7v6DC+OdThQdgfHj8rubzO/dd1fE91zFQXahf3vdI0wZ37Fk4nwnUjMhmtK9Xx59B1wd0HFp12hOdKMpYgmztN5broboyTkJpg704Zu6GEZXoRkSZoVG1qa9mx++9vF6kctCmcuGiRxMmZ4zP7pKSy3xmvB5JQ2Wuzd6eE3fTU87khoS4ITA03a2J4IXoQ9b+jmlS7BasvmuzeKy/yrUhJSZmAZV+hmzdMVjdG3HxTZ2VNudnQBfkkNz/26HROuy333JwvarRG3GxmxNCO9Dw7dI2VLPm6169t7bv5RmHczbaBbxuYbhifSRNJDC8k11iMmxtVG7vtY7dOGy5FuuBgW7nZ/uh9nC8Mu1lKqYLbODfvB5SrZ7tcV3XZC3SzLrhz3+672bK0xI7Zui64+9qpmy1bdBeuh+/71jsB7y66hEgT7N0tk627VA5O3Vxfsamvjrt576aadV+ouWjy1M3RiJurBwlu3m+zf7vr5r02pqfc7JsaXs7EcEP0QMa7+W7q5vMw8V+MEKIErEspPxm5/U0p5bcXemQpC8GMaQxxVWQsLbaJVA/Pi2IbZPU2cLdumpwcqY69pbJOZSV+duBZZCo1wYu7ZfJ1l2zLJ9Q1GlWLwEr+p9JYyVKouxCdZiZFgNQFqzut/jy+6n6L3dvlmdJJZ0IIDm4VVSMEJyA0NNXQqiuNn//aFr80IlIpZeLon2COFLIwkDx/qhYh6Ja3bNwwExca5sXOatjZ6d9dIQS5vE5upOx50TNvk3CKFi+K1vQ7aoKTjfzEkRV6EMV25BaoURp2y2P9WaMvWSOUGGGI5YT9+43+nuUErD+to/sRTt6kvpIdFnfKUpK6+eXjWrnZjXAGgtseUoImlJuPD0NkJCmWdaoDbn77gzfhw7Mfk9QEL+713OwRGjqNik1gJafu1lez5OtqPM1kN7fZuVO6uNEvQrB/q9R3c2BoOFPdTOy8W4AgOLubg0Dy4kl3EaLr5s1tk1J5udw8yLvaly/wyCbTKVl0SjO6eTPPyYReKrofxeb2C1Strt2Md7M9yc2dgLWndYzUzXOT+G4JIX4M+C7woRDiXwshfv/Aj/+XRR9YytUShhLHiS5s3Ms8BL5MbGzh+5JS2eDOfYv7r9usrpuxKV1zBTaaoFWxObhZ5HgrPzG4BZViunOnjJMziAQEusDJGYhIDnVR1CJYe95I6LYwP76tGl91CpmxlezRmlMhRGIDKE1XAetZePbE7XZNPO1mvfvcH+oAKqVUq7zOeOfjy+CsqckikuRPHMoHbeyWd+Gf17yEE3YYAlOjsteObWwimNzQPNv0sdyQ4pHD9mcn6WiiJSd186tNz80XNe5lHvyJboZS2eDuA4t7XTdr+mlw+4UPPz//E/fdXOJ4Mz8xuIWum+/O4mbJ+rPFudlJcPNgOm4vCy0OTZvDzY9d2u1hN+8881XA26XvZvdq3DzILKnJIhx0s780bp4UeAamTnV/PjfnxtycjiY6C5OWA74K/F4p5VvAnwT+hhCi9w1cfP5MypUgpWTnuccn33N48pnLJ99z2NvxruTkl7G0xPNXNjd9Jesyd+1822DvTpkn37/KszdWMIIo9oSmB1Fim/pFMfo+rG8ZsRcnUQgPP3WJZpwNqFbx4zs1Hh2qupNWM+ST7zk8fujy6FOXz37bxU0YL7QozjJLz3QDbn6s6mHKBx3WnzbYfFSHBc1LPBOaiK3tigTU1nKq4+MERl9Br7toPzUK0EJJ+eDyUrlT5iJ18yuIlJKdZ6du/vh7DvtX5GYryc1CzTZN4l/cf31xB5XAqJtNP9nNlz3bdHABWgjB+ma8m8MQHn02u5tdN4odFSQlHB/EuPkTl88+dmcas7gopjWANJ2Am58MurnO5uPlcLPUBM2YniiRgNp6dmo97axuLh1O7r6dMsykKEGXUr4AkFL+E+ALwH8phPgyyU22U645B3tBvzNeFJ0OBz8+vPyW6IYh+s2oBtE0WFmdXCt6VSmppyRLfuZ/PFJiuoFqIHTOi5jBXcxiyWA9prkDqFXi0W6HSQRB8ip+4El8X/LssUcY0m+a4fuSJw9nF/V5efuDN880bmDtWQOtu7ovUKv7GTegdLQcQd/JRq4f5EoBoS442szTKWSGOjMnEaGkG99ITb3m7EDdWMpSkrr5FWR/16deG3bz8VHI8dEVuNkUlCrxbq4m9HF4653gcrrYT+MiloAu0M2D1yqlssFagpsDX9Koz+bmcIKbfV/ie9G4mz01w3gps6yk2mEfc7MTUDxeDjcfb+bH3Hy4lcfJZ4Y6MyfRd3PCz1M3n51J73pDCPFa7y9dof4I8KPAv7Hg40q5AqSUnBzFNzk4OriamV8bWybrWwZmRqDrUCzp3H3NmjjL7TK75SbRrCR0ODY1wsz0QMRwA7Y/PWHrYY3NxzVu/fYxdnf0wTyMNljqdTMcRUo1Z3gWLDt5FT9X0KifBLFX21JCK2FI/EVzlnQ43Q8x/Gjs+keTUDrsUDhx+qOirgyh6oGefN8KT1+r8vT1Kq1uN8eT9Vxi4CqB0BDs3S5yvJHnYCufeKEXLrizesq5Sd38iqHcHMa6+fiK3Lx5w2R9c8DNZZ17D5LdfJn1lZOI22nrTR+YZWyQOermj49VKcs5GAxye12GRzmTmxN22IWAfF6jdjL+XQK1GXpZbh5kWgNIw4+GmiT20CSUl9jN7bJyc21tmpu1vpsPtye4OR0ddCYmvVs/A2hCiB/s3SClbAB/GPhTiz6wlMvD8yIOdn12nnuJTQ7iRsNeBkIIqismD96wef0HsmzfzpCZ0Izj7Q/evNRuuUk0qjZuVrWXl3RX5nTBQbfD8USkZOuxai7Qq93VuzVC+jlaxw9K1DRF7Em01/FyFnRdsLI2nlKla1BdNVXTqhjnSDlf04yzkjQmaR50CdXdFjc/OV6OGlUhVN3PwJvfKWY43MoT6EJ1GKX7vdPUd2/vVgk3n6FZtemUbTo5c2y1OBJQXxnvJJmyVKRufkXwvIj9XY/d517iRuGVunl1wM23MomNsr7x9S9e8tElU1/J4maNMTfvb8/m5s1RN4eS9aeNC/PCJDdnZnWzEe9mTVej/BIbSl6Smwc5b7adHik3by+xm9sla7Kbbxf7bm6XbJysGTvGqLFikzI7id1zpJTfAhBC/CshxN8A/gJgd//7+4C/cSlHmLIQAl8SBBLHCdl7Mb5rO4qdXf5dnXM3sLhIhDppZZwAqx0QmhqdQgYZ0+V5lGzLR0g53llPQqHmUlvPzX1Yb3/wJr/5U98ml9cwdIE/suqphsHP3mVxbcPEsjWODnzCUM0hXl0zMQxBrqAnrhTnujXUUaQG29dPQiSSYkmnUjXwPYluCuyEsQOzcNYdg9DUCUwN0xtfKYZu+/5QsrLTYv92aa5jWjTtsq1WjaUaUWV31EiCwQ6ePQ62C6w/a2B1AvUzKamvZGkXM1d09CmzkLr55cb3JWEgcZ2Q3ZncvPy7OmcpE1k4QrB3u4TVCch0lJvbhYxq/zyFbNNHyJj4U0K+5lJfm9/NX33vS/zi3/mr5Asaug6j5cBCQOkM0wlW1w0sS+PoULm5UNBYWTfRDaEyrOohMmZDY9zNKhOrVNIpd91smCJxJNBZmLWjdmBqhIaGiMmwAuVmEUpWdlvs33oJ3HyzwPrThkqB77q5tpqlPUvX55Q+s/xr+WHgzwO/ARSB/w34Nxd5UCmLIwrVWJd2K0KI5Lb0gwgBG1vLfdG7VMFtDyHwsiZe9myzZbVgfPwCKKka52yC8YUPP89HH8Bv/tS3uXPf4sUzj3Y37SmTEdy4mcGYkKLaS2M/OVaBa7Gks7pmUCyNrywWimounuvIoZmIhZLeTW+WPH3k4XROR0GdHIWcHIX9871pCm7dsxI7Pyfxue98BebYyT+4WWTzUV0tMMRcyPTrYKSMzyNbFoQgzBi0MsmneKlr7N0p92fkepaOTFOgrhOpm18iwq6bO2d289n8ctnMey5eKELg5kzc3NneOz2MHwejcX43w2mQe+e+zYunasSPQGVVndXNpbLOyqpBsTzu5mJJ5+ggwHOH3Vws693mnpKnD12cAXereu+um4Vy8+27k8vFpvFz/g/Ndkch2L9ZZPNxHRHJ2O7DArUAsfTM4OZI19i9m7r5vMwS4PpAB8iiVok/kzJu3SflOvDimXc61mXCyrCmqxRU2xasrqtdumVm6YLbc5Ak3Uig5txOQ0ryNZfSkYMeRrhZg5P1HH533NHP+T/EH+fbSCT5ggpC8wWdfGF6/dHzpx6txmlAenwY0GyE3H1gjc0gFkJw+57FyVFAvabEWFkxKJXV8zidaCi4HXkJAHieo7N5/gAAIABJREFU5PkTl7sPzpaa8/8efAacvaGJbxk8e71Kru6yutOKv9MSx7XzEGR0ghnqwlOWjtTNLxEvusHtNDfrOmi6wLY1tUu35G5ehpKhi8JJWKyOBDizBMt9N3fQQ4mbNTheHx539PYHb/IPf/JfUihqZHNqduwsbn72xKPdPPXp0UFAsx5y9zVrbKdVCMGd+4NuFlRW9L6bO+1oKLgdeQkgwXMlz+Zwcw/7o/f51tdm39n3bYNnr1XJ1R1Wd+O7CcvUzSkDzHJm/Kcoif5+4PPATwgh/o+FHlXKQghDSasZH1CMks1qPHjDZvu2tfQCXab6nosg0gVOzhxqShAJ8C19pvTR0mGHld0WGS9EDyXZps/Wo1q/Vf23vlnh1/7YD/PZb7vs7wUcH4Y8e+yx83zyyAnXiYaCWzjtvthM6O6oaYJy1eDWXYu7D2zKFaMv27gRQ/HPq7o+noXzdOuU3VmLrbI1VqMqgVbMTMOUlCsgdfNLQhDI/sLzNLL5npszqZsvmcgQ/Zm6/dsEeDO6uXzQc3PUd/ONATcD/NR/s8Kjxx77ewFHB8rNuy8mN7FyOtFQcAvKzd6Ezss9N9++a3H3gTXm5lm+i64jk+t5pzCPo6UuaFWztEqZ8RpVSMtrUoaYZQf3P5RS/rPu/+8APyqE+PcWeEwpCyKccTB8b6ftOvCNr39xuep7zoOUVPbaFE+c7t8h1ASBqdEqWTSr9tTASkSS8mFnaM6fAIigfNDmcLuI6Tjc+qV/NCbD+klIqayTy8evGCZ1cJQS2q2I0sjHEPhyKAXaNGFrO0M2pyGEwMyIXnnJZGZM1+sxa13PNI42cmScYOjiIzB1jrfy53/wlJTzk7r5JSEMu/UQU86FQkDlDD0SrpqXy80tSieu+ogG3Vy2aFRmcHMoKR3FuVlSOuxwdKOA1enwuV/7dcKBRk9SQu04pFgOyeUS3NxJcHMEnVZEqTx8u+/Lfgo0QMaEzZsZstkBN2vE1uiOEkYS44xpTedtLHW8mSfjhBj+iJs3UzennDL1TDkg0MHb0iYW1xDT7J60EhrN9c7P5apOvjDbynAUShw3wtAFGetyV5MXGdyKSAmtUHcRETh5k6PN/ELTRQonDsUTZ0iAkZT4lk5jdbbOtoYXEhc1ClDNhIDth4+IYhpq9ILcpADXMOMD0rjOy1JKHn/m4g+s7voePHnoqWYZZZ31LQNNmx68CgEZa3aBXlS6utQ1XtwrY7cDTDfAt3SVhpbu3qYsAambXx4yGTExvu2dciorOrn8Gd1siImTBxaF/dH78LWLf9y+m2suQqqyneNFu/nYoXjiDvVliKTEsw0aM3adN/0wdhFDuVnVjm5/+pAoxi99NycEuIYh4h9bMFYj23Pz4M6r58GTz7puruisbxjo2nijq1E0bfbOzhdJpGu8uF/GbvuYbpi6OSWW67MUmHJuhBBsbJnsPveHghRNU91wRXd+6awyPDzwOdwL+kGPZQtu3rEmNkK4KBa9c7v+tI7VCfrBpt3y2XpY4/mDimoBP4VMJ6Bw4qCFEZ2iRas0Pa21dDQc3ILqDphveBxFcqYOzKGpIWK2RHtz/k5JeKwJT5EvaIkBaXmku2O7FREkZAxICfVaSBhK7jywePHUVyvJCXP7trYzM3drvPCLKiFwswaGF1A4dsg2fRoVe6hmKiUlJeU89N38YtzN6xtmf7b4zG7e9zncvxo3gxrR9u45ykQSkZKNJ3Uyzqmbsy0f62GN569ViGZoxDOXm4/j3Vyouxxt5WcKrAJDix+bh9p9BCB+QlDvR4kUum4O49w8suPfakaJ2Xy9QDoMpWpC+dSjk1BKJARs3ZzdzT3Ou3s7eABu1sTwQgrHDnbTp1m105rVlD5pgPuKUa4YmKbg6CDA9yXZnGpUYZpnW+FtNkIO94KhhhhOR/L8scudOZsOnIVFBremEwwFt6DkIqSkUHOor04eBVA47lDda/dXe7Mtn8Kxzu7d8kQRahNSyMWMAW6ka7SKGXINb+j4pYBadxf4+f17aDFRam9nNfEYhOD2fYvnTzw8Vz24rsONW5mxVWLfi5+B2z+e/kB51ewiDNX9hYCT44BWK8I0BdWVszVROU/tbRwijLjxqIbenXso8SmcOBxsF+mco95HhBHFY4dcwyMyNOpVG6eQ1g+lpLyqlKsGZkZwuB8QBJJcTo11OWsH+WYj5HA/xs1PPO7cv5wxI7m/8J8vpHNyxgmHgls4dXP+xJ2a6VQ46lDdH3HzicHundJEN+tJbpZdN+szuNnQ6OQzZFsxbl5Tx/30wf3YBeppI4KEJrhzr+tmr+tmQ7B9yxxb1PAT5tP3j0dCqxEhtgR3Hth9NyOgdg43w8V21BZhxI2HNfTg1M3FE4f9m8VzuVQLIwpdN4eGRmPFxsmnbr6OpAHuK0gun1xnmYSUkk4nwvcklqVxfBg/n8/pNgRKGvh+EVzYCmACphufSqRJ1FyyCYgworrXHhKYJiHjhuRrLq1KcvDv5AxyTX9spTbUNaIZBNrjcKuAFCq9WgKRJjjezPe7M/uWxT/8I+/yb/2fv4oEtCjCkFE3/W3y9yKT0bj3mo3vR8iIbh3t+LHNMptRCPD9CNPU0Qde38qaycrazC+3zyK+F8Vjpx/cQu9iClZfNHlaqM6VEjUqZtwQq+1zspqlMWGOYqbjq+MJIjqFDM2KPdOiR0pKyvVgbje3I3xfdmeSJ7i5o+5z1oB5HhbVOdn0EhomSci4k92shRHV/Rg3OwH5ukernBz8OzlDzcAduT0wtTOdgw+3C6zstMg3XEDV8R5t5vujBH3b5h+9+4f5/K/+XwCIKEJqGhtltRkxiYylce91G99TzaYS3TxDUKrcrObdXoSbQQW3F/m9KB05pw7l1M1rL5o8ff0cbv6shhaeutlu+5ys5SYunlht5WYtjGgXMrRSNy8FaYCbMpUwkDx56OJNWfkDdU4JQ1jUZL5FB7eASj+NeZ2qW+LpPxmr5VOoOWihpF1SqU5W53Qw9yCahFzDmxjgnmzkybZr0J3zJlGru4ebObWj3B0rMDVFWhMc3ShwvJlHRFIFxyMn+yff9wYf/kd/mru/9VsYvs9/91d+kP/vx/76tLemz6Qd/yCQtJqhSplKqPcG9RZdRW3YWciP7IT3EFKq2h/77KfQwsmwmEF9PyqHHZpVO3be3WhWgNUJKJy47NwrpyJNSXlFCbpu9r0ZGkgK1cxq0QHuIh3tJ/ii18m4h91SmTZCSloli3Yxg9UOEheucw13YoB7vJ7HjnHz0Wb+1M05Y2qKtNQEh9sFjqJkNz/6ge9n99Yt5eYg4MlrD6ivrvKLf+evTnzsHpM2F5Sbg9ncfIa+F9O46OAW1GcW6+ZIYnphfyziWegFqWNuPmjTrFjxbh7JCrA6AcXUzUtBGuCmTGXnhYfrztaBWXKxJ8ZBLiO4BfBsA882hlKhlNAEzW6AWj5oUzrs9E9qdtsnXzO6acDxNbDTdmGDjM7z+2VKhx2sTkCQ0WkVM6zutk9TiiVTd/r6z6mJiSdYJ5/je7/7LQD+6F+Hf/Cdr/Abv/MvTn3cSbhOxOPP3KmzHIVQzcwuqiZsUd+NuGZcPeaVV67px4oZAZYTjKVDiUjGZgUYfkjhxJm5yUlKSsrLxc6z03KRaQjAuoKGQBeJZxv4lo7phmNu7i0el/fblI4G3NzyKZyY1FZs4iLcXpbTJAJL5/m9MqUj5Wbf0mkXMqzuNNEi9XhCwvGUnb7+c05zcyHP937P7576OGfBcSKezOjmyspwVtV5WERwCyA1DcYG+SmmfZ5JZJvxC9pSqPR4d6TBm0jICjD8kPyJQzN185Wy3NsnKVeOjCTNenIrvcHFRyFgY8tAW8Cq1WUFtz32bpdolSwioQTo5Ax27paJDA3dj/qjeHqvVJP0V3IjTYyFuFLQD44nEZo6x1sFdu5XONguUN1rq92+CPWnu9NntfyLfsn8yC90VI3MOdh57hFF4wLN5bV+kyrDFKxtGmxsJe/zh4HE9+XEubw97I/eP9cxT6JRtYdmHsJpw665mllEEsML4xMhpEpHHyXTCWI7jPSyAlJSUl49okh2+xgkMOZmE7HgHaXz+mMqQrDbdbMcdPO9MpGuofsh5aM4N/toUiJjXr4U6jw/jTBz6ubDGwVW9trogey7WXR3+qz2xbsZzn8NtPMswc2FYTevbxqsbya7OTiDmxcV3EKym/2MTmjO52bTi2LdLKSagTyK5aRuXmbSHdyUiUw6hQkNqisGrWaomg6sGmeuH5qFt96ZXFuzCGQ3zfeoN/N0IJK3236v58IQmoRc02PvdonNx3WEBFBp3SdruX4N7KxknAA9jMaeR0goHndw8xefCP4jv9CZeyc3iiROQsfFTifi+37H9NXMwJc8787nE6jxB1s3zcTv1dsfvMkXFtGts0u7mMHqWBROVM0UAkJNY/9mca7HKx530EI59pn2Omn6Md2ZI10kdt8ML2iVPSUl5ZoxQc6apnbhWs1ooW4e5K13goUFM4NIXUt2cyvZzdmmz+7tEptP6qeNnCScrOf6NbCzohaz491cOHHO7PpZ+dw53Ow68V8Ypx3xxgxu7s3Odbqzcw1DcOOWSTZhdNEig1ugWxJmka+5/dtCQ2P/1nxuLh11EFGCmzN6bMpzpCV3xp5l2kbKYkkD3JSJaJrAtgVOzMmxUNBZ3zQnrvadl7feCXhX+/LCHn8qMY0KVN0MYyc2lYas4VsGT1+vYrcDRBThZs25TnZaJBPn5k3quHxe5g1yJ/V0mGXjQErJ44F6MomS6tNHHvdft8Zqi97+4M0Lm3mbiBAcbxaor2SxOgGhoeFmjbnn7RVqXmLazGHCuAnf0gkNDeEPX1CpnYc0BSol5VVE0wWWLWIDl0JRZ30zw/rm5R3Pd//cjy1k7m0iZ3azwLdH3JwzZxotNPbUkUQmzJvXg+Vz8yRmUZmUkiejc+19yZNHHg9et8emKCw6uAVACI62CtRWL8jNdTfRzQe9xZQRPHuSmxc/TSRlMle6xCCE+MNCiO8JIT4WQvxCzM+FEOIvd3/+bSHE77mK43zV2bqZQdNOzxtCqPEw6xNSTC+KKw1uE+jkTMbX+XppyN1GFULg5E06RSs2uNWCiOpui+1Pjtl8VCMbk87iZs3YEpNIQLu02Lb186QrCyEoluJPKaXK9N2DTjsiiLk4kFKNDhrkUoLbAUJTp12y1Mr8AobJSzFhxVcI9m6XCEyNSKjOm5HoZgUsYBc/JSV18/VgazvGzQYLXXRO4qJHtM1DJ59JdnO5G3AMujkmuNWCiOrONDcbiGjcVcvqZk0TFIoxfun2wphG0lz7ODdfSnA7wFK6ef3sGXspF8+VBbhCCB34K8A7wA8CPyGE+MGRu70DvNH989PA/3SpB5kCgGVr3H/DZnXdoFjSWds0uP+Gfa27MZ4LTZ3UQl0Qad0/3Y6Ks3Tu04KI7c9OKB47mH6E3QlYe96gdNAeu5/UVT1vTy0RqsakVV786uA8It24YcY6xrKnf1cCP3nl2x+4xrjs4PYiaZat2Lqh0NAIJnWmzug8f1Bh906Zg+0CT1+vztTMJCXlrKRuvj7Y2QE3l3XWNw3ux+yoLZpvfP2Ll/p8iWiCvdtFFWhonLp5K6+mI0z79Z6bT4bdXDwcdrMeyng3WzrN0uJnDf/sb7w48+9sxrlZzjbSL0iaoCEZ6uD91fe+dKnB7UWS5ObA1CbW9J66uXTq5rS51FJwlTu4fwD4WEr5qZTSA34F+NGR+/wo8L9KxT8GKkKIG5d9oCmq3mJ13WT7doaVVfPCOuwlsTTCTMDLqlSnvZvF7kltZeIIoEGKx85YrYcmoXzYQYS9bsmSjaf1fr1m775CqC7Kl9V+/qxBbrsZxXZo3H0REMWseA9iZ+PrWYSAbF69Xvuj969tcAsqbcnLGv3mZZFQF2H7N4vTV5+FwMsaOIVM7LiClJQLInXzNaLv5lsZqpfg5ji+9c3KpT9nEl7W5OkbVfZvltjfLvD0jZWZF4RLRx1EOO7myoG6HVBufhLjZuBkNTdbPc45+dY3K2e+RmoluHnnmT+bm2NQbtawP3p/eTckZqRezeLZ424+2J6hplcIvKyZunnJuMoa3JvAk4G/PwV+eIb73ATOvnyVAqhmA/VaSKMWouuCysrZB8svms995yt89TqsAgoxV4potjWhFb0b4uY0TC/E8OObWJRqLs4lrBKrg5L82/9Zi7//7Z/nN9/8pal3r9fih+sJVApyvpD8XctYGoWiTrMRDolYN6BcNpRA42q8IknhxCHf8PrdqtvFzELSlc6NprqAWu0Aq+MTGhrtkpXOy0tZJlI3XwFRJKmdBDTr0dK6OY63P3gTPrzqoxihm4Z8VuyWH7/rIwQZN8DNmZhuiB7EuBkonjg4xcWmKPf41t8uE/0PP8GP/+zfjGvkO0aSmwGcTjTxu2bZqtPyaJBsGIK/+Md/hvBrCe91z811D6ldAzffKWG3AzIdn9DUaBdTN19nrjLAjfvWjF72z3IfdUchfhqVKsWmmaYHxBFFksefuXiu7J+kmo2Q1XWD1fXlqBe47PqNqyAwNDKEscFr2K31EJFUEohZctXCCaMhLgopqe61KJy4CAk/+e/U+Pn/+Wdw//TkTMQkb8kJPxvkxi2T4yPByVGIjCSFks4vf/GncXMJc3+lZPNxnYx7OrPY6jSx2xZHW4XpT3gVdBdG0vrZlCUldfMlk+TmtQ2DlbXlPk/8nP9DV30IF0Zoakh33M1I2XezNsnNU3ZCL4RIsrLXIl9zqX0P/vc7f4TPH/xz7rYnry2d183btzMcHwacHIeYFZPcH73P/2j9IUIz4fspJVuPa0Mzi61OE6ttcbzEbnby5lyLIynLx1UGuE+B2wN/vwU8n+M+AEgp/xrw1wB+IFu5hLPM9aNRC4cECuocfbgfUKka6DFzvi6TVyG4BaivZsm2/O4YIYUEPMvoz1b1LCNWoJFQo2sWzcpOi3zd7YvJCCL+0p8/ovRf/QT/7n/7NxN/r1w1aDW9sUPXBGRz01N3hBCsrJqsrJrYH70/tXFJtukNBbegUsryNZf6Sna+WbWXiBZEVPdaamaegFbR4ngjl6Y5pVwlqZsvmfpJEOvmg72ActW4krTjWVmm9OTzUl/JYse52R5wsz3BzYXFu3l1p0mucZoF1jTz/L3Nz/He83/AlnuY+HvlqkG7Fe/mWepwhRCsrJn8+of//kyfea7hDQW3oNxcqLk0roubd1vkml03lyyO11M3Xyeu8pP6p8AbQoj7QogM8OPAN0fu803gT3Q7Nv5BoCalTFOg5qQxkvrZQwhoty9hV3ACb3/w5tIHt6YTkKu7GG5yqs8seFmTw638aSMMoYbVD81v0wRHm/l+PQio+4WmRqMysAsiJaajUmq4oNVjEUaqZf7oeCIJ+39bn1hrky9olKs6QqjvlaapPzfvWIgZ05LeeieYKbgFyLb82HRvUPOKlxIpsVseheMONz47IV9XFytapALzrUf12AuolJRLInXzJdNsxNdHCqFKO5aVZam7vCg3uzlTeXeCm2WCmwNTpzk4GmbQzRd0PtfCiHxjvMTJ1wz+RfV3TPzdQlGjVDl1s+i5+e5sbn7rnYCvvvelmRc0ss1kN1vXxc2NATefuGw+Tt18nbiyHVwpZSCE+LPArwE68IGU8l8LIf5M9+e/DPwq8C7wMdAG/uRVHe/LgJGwCixRY3+ukmVOcxKhaviUcYL+jD0nZ6rGQHPWZ7TLNu2ShemFRJpGGNNBt1Wx8W2D4pGDFkZ08iatit2vCTG8kI0ndfTg9ALocDNPe8ZmV0kYQYQUDK1ig3rphq8uIL763pf4pf90B+cLf2v4PkKweSNDdSWi1YrQdTWTUZvxfbI/ep93v7Y18zzFUNdUitXoD4T62bKh+yGbj7ufWXfM8VBDE9R7bLd8nEvYDUhJGSV18+WjTXCztqQbXW+9E0y/04IRYcTGkwYZd8DNeXO2pn0JtCo2rbKF6YZE+gQ3WwbF4w5aKMfd7IZsPB1288FWns45px/ofoQUAhEzf/eTym3YSf5dIQRb2xlWVs/m5nkz6wJDJLo5cezOFdJ3cxhBFO9m0wux20GawnxNuMoUZaSUv4oS5eBtvzzw/xL4jy/7uF5WKisG9dr4Lq6uzZY+uii+8fUvLnWa08pui4zTTYPtvnd226dy0OZkI34A+EwIMXWskGcbHG6P1KtISb7msrLbQsjhk/DaTouaH1Jbn/+4AlOPrabrpWr1+PmvbcF7X+IX/85fHbtvxtLIWLN/p/rfgRkD2x7NsqU6X46klEkh6CyhhNaeN2Obhw0iJJhuiLOkZUopLz+pmy+X6opBs57g5hnSR6+C7/65Hzvz+fqi6bsZTt3c8ikfdKitJ/RtmAUh8O0pbs4aHGZHOuxKSf7EYWW3PRYgrb9ocexHNNbmP64go8fuIErUbN63P3iT3/ypb098jFnd/NY7Ae9qX4Y5M+taFZvSsXN93PxsupuRYLppgHtdWM4zZ8pCsLMa61tGP3VUaGAYcGvGFJVpNOohjz51+OR7Ds+fenje9NSqZQ9ukZJ8YzxdV5NQOHGv5Hg2H9VZ2WmhyfHVUQGUDx3s1vhw+pmfQhPUV7NDM+GUmKC2Nt4k5qvvfQn7o/fneq7Pfecr/Ndf+NPs/mW4891Dbv72EcWjzsxpQGFGZ/9mcSjdOzQ0dm+XLmVcwyRMN6C602TtWZ38iYPmh1hOMLXjpdRY+vqklJSUiyOb01jfjHHzvYtz88Oum1/M6OZpzFJCslCkVOUdIzdrUnUzvorj2XxUY2W3jUa8m6sHnXOl50pNUF9JcnOOL3z4+QvZWX/7gzd5V/syVttn67MT5eaPjyicwc1BRudguziU7h0aGrt3SlfeRdl0Btxcc5Wb3eluRgM/dfO14Up3cFMun+qKSals4LQjNF0FvRch0KMDn4O9oH/ua9RCWo2Qu69ZZDLx6yhLH9z2SDifj6YJXQa5erep0oT7CKB06ODk509xra1mCQyN8mEHPZS4tsHxRi5xx/nnv7bF7/r6F/lL5r+auoIM9GtsMz/bYPNJ/bSZVSip7LfRQjnzCrxTyPD0jSoZJ0AKgW/pVy7QXM1hded0hz3b9AlMHRmzKDGIRKVWdwoxK8SRRA8jlXqdji5ISXmpqK6alCoX7+bDfZ/D/VM312shzUbIvdcszAQ3T2MZ0pOTvAzdKQSXTL7ukXHDqbtGpcMO+7n5dwBra1lCQ1A6cpSbswbH67n+oui72pf51Xf+Mv/y7853ef/V974EH0Km46t5v/1Gk5Lqfhs9ktRm3IXuFDM8KSyXm/M1h5V53Wxo8bu3qZuXkjTAfQXRdUG+eHGrUFEkh4Lb09vhaD9g62Z8oHUtglshcG1jbOdNwpWkqeSa47vJcejBlGYbkaR01KFQU7vQzbJFYyV7OvNNCFWLdIZ63m99s8IX+Dy893mAsdTltz94ky98qH7WS20rH7THan01CaWjDvXV7Owz6LqD1peCSLK62xrrHmn4IVIDRjZPenVKvbsfb+SGLwKkpHzQoXR0mipWX8mq3fRlnCeYkpIyF4tw82Bwe3o7HB4EbG3Ptwj6rvblCzi6c6IJPFvHcoZdJ+FKUmBzMZleowhUj4uJ94kkxRE311eyp4GTEDSrWZrV5JFb8wS5oxsOlf1OvJsPO9QGj2caS+RmEcl+9luPSW7u0bv70Xp+zM2V/TbF49OMgfpqltpq6uZlIA1wU86N78nhK/QBkrozL0v3xVk42sqz9biGjFROfyRUHcnxeepv5yRKaqo0gAq+J1y4SMnmk/ppXTFQPuyQa3rs3C1f2Il57DP+cPw+mbiZg130ILqWqbqWExD3D0KT4Jk6IghB0n/ve6+/99/yQYdO0er/XvHIoXTUGZJy6ahDpAsaK+lc0ZSUlHg8VyaNbKXTmi9N+e0P3ow9l18FR1sFNh/XYMTN5+qNMSeRNpubJwbfUrIxMte9fNgh2/TZvXu21N53tS/De+MLzaO8/cGb/Jz/Q2MbDuaElF09iAivoZsznQAZc62qSXAzOsIL+38fpPc+VA7b7AyMaSwddigeO8NuPuwQaoJm6uYrJ63BTTk3uiES04VMc/wUeZ2CWwDfNnh+v0p9NUu7YFJbzfL8QeVKgq9mxVYn6AHkyP9HuqrTScJqB0PBLagTuumq7r2XiZ/REzPNwiXstDgJEUbYLQ/djxLrlAJT49mDKrUVO/F1Z0ZGXZRHgltQn1f5cLnHaqWkpFwthiESSyaNGDfPQj8LZwnwbIPn9ys0Vuwrd3Ojap3bzXbbj53rnnGDucfeffW9L/GNr38x9mff+PoX+cKHn4/NpptUa7qMXZAn0XdzEI7tSvcITY3nr53BzVJSOnLi3Xx0BTXgKWOkO7gp58YwBPmCRqs5PMtPCFhZG/6KXbfgtkdoaufrynhBeN1a2Opeu7uaK5EI/IyGHko6+Qz11WzsaIMelhPEnuSFBKtzueNpamtZrCf+0PFEAhoDIxeWGd0PKR45ZJseph/1V4d7i8SDryAS0KzaRIZGfT1P6dhFj6kVi/ThFCgtjNdt0u0pKSkpoILYXF6j3Rp38+r6y3H5F5r6lezYjuJlTY7Xc1T3h90cmBpaJOkUlJsnBYeZziQ3B3P31fjWNyt8K+7aa3S69QC19RzWQA0udN1cvR5uNryQ4rFyszGDmxsVm9DQqK/lKB+7sXXco6MHtYRab31KGnrK5fBynOFSrpwbtzLsPPNpNtQKlxCwsWWSL5yuAl7X4HbZaFaztEoWdicg0gRu1jhT6lJoaLFzbqVQFwuXidudJ7yy21IS0gT1FVvVsCwpdtOjfNDB8AL0rsf6acbd97T31kbdWRFCqguDzsDiQX3FpnzYGbuAGHrtQi1eZGK6nqbdHFNSUqZ/kVgnAAAgAElEQVSxfSvDi2ceraY6hwgBGzdMcvmznz8+952vzD025lWguZKlVV6Mm4NL3jUddXPUdXN9id2c7bpZn8XN2unt9ZXs6cK+ENSr9lhZUCSgtjLQk0SoxQvTH3ezZ6VuXgbSADflQtA0wfbtDGEoCUOJaYqhDpDLVLfzMiB1bShYOgvtYobqnkCGsn/y782naxUvb/e2h1PI8LyQUWm9S9aYIeMEVHdbWJ2ASBc4WYNs059a2yFQ/SqONvJIXeBmzbFd9fpqFi2Sww0qVrI0qsONvY4386w/bYzJ9njz6nctUlJSlhtNF9y8YyW6+Sz8SBrcTuVcbi5ZVPfaSDnu5nbJmvSrC2Gp3dzputk5h5s1gZszx8qhamtZ1ezrZNjNzRE3H23mWX926ubeyKar6M+SMk4a4KZcKLou0PXhE+Fb7wRLVbdz2WhhRK7uYfghbs5UTSauUBZSE+zcKbH+vInRbaoQmhr720WkfoW1NUsmUMML2XxU68tLDyW5pj99Vl4PTc3pTey23W2GUlvLqaYdhhab+uXkM+zdLlE+aGO6Ib6lU1vL4Z5j1ERKSsqrRZybz8JSjAa6YLQwIl930f0IJ2eqc/UVu3n3bom1Z00MX7k5MHUObhauNi142dzsBmw+Po+bBUFGT3aoEJxs5qmtT3FzQbm5st/G8EJ8y+BkPbs0XaNfddIAN2WhvPVOsBwjBa4ALYz6XfaQ3S6Pxw6epbN3p3ylwgosgxf3K+h+L8CdIaUmkuSaHlYnwDc1WmULhKCy16JQ90BKOnmT4838pac6L4LS4fiYhDN9YhFkGy5206NdtvDs+NOt7Mp2Em7OZO9O+SzPnpKSknJh/Bd/9E9MrNm8TsS5uXjs4NkGu7dLVzrL1LcMXjw4u5vzDY+ME+BndFqlDCCo7Lco1F2Q0MlnON7MvRRuLp/bzZJc3SXb9GiVLPxzunn3burmZSQNcFMWxqsc3GY6PpuP6/1h4j1UR8SQ4nGH+urVN62KlV2vG8nAqq0WRmw9rKEHEZpUKbKV/TZhRsfwwv5Kaq7pY3dqPHtQRZ5jt2AZGJ19PCs97wqgeKJmGRZPHDW79jyNyiJJoe6Sq7tEmpqFeBWzmFNSUl49rsXc+hmw2j4bTxLc7AQUjx0aS1BnOrObg4itRyNu3msRmjqGP+hmD6vj8/y16rVoEjWJjJM8XnASsW4+dqitZqmvndPNNYdcw1Pj+ypZ3NTNV04a4KYshFc5uEXKsZrJQTQJ+Zq7FAHuICKMWH3RJNtN9XFyJkdbeYKMTnm/jeFHfaloUslCG5ljK1DD1Ku7TRor2cSV0etAKMa7LcL4bb26GyEh1ASepWOPjGESUs2ubZWt+UZYSMnm4xoZN+y/99mWr4bKn0fMKSkpKVP4xte/+HLs3ko5VDM5iiahUHeXIsAdRIQRa88bZFsqTdzJmxxtKjdXktzsjbtZiyTV3RaNqn2t3Rxpc7hZF/gZHSvGzeXDDu3SnG6OJFuPa5iDbm765w+aU87N9f2Gpyw1L1M601kx3TCxfXwPPViuES8ijLj58THawKq23fbZ+uyE569XyTe8MZnEzEsHehcJHvmGh2cb7N264tresyAldjugeNjGjlkl7gmz/7qFoFax8HMmfkZXiwEHbbKdmHo1CdmGN9fFU77u9YNb6C4kdMXcqNjXbi5hSkpKymWTcUJE0mDgLss24kWEEbc+Ph7acbZbPlsPT3j2WpXcWd1cc8nXXeXm26Xrs5srJXbbp3TQwUpwcyRO3yMpBPWqhZ818TI6YUanvN/CjnMzqgNzY8KM4iTyDbcf3MKwm5upm6+UNMBNSSQMJY16iIwgX9DIWLP9Q7U/ep9vfe3lSGdaFCKSGF54JQPp41jdaQ4Ft9Bd8ZWQP3ETB58n0TvJZ5yAld0Wh9vFizvYRSEla8+aZFveWPpaDwEg4ckbVbRIqu6LIw04pBCxq8vqDZ3v0LJNL3bXQaIWIq6iw2ZKSsrVEAaSRuPsbp6Htz94k69++Or4XIQS3Q+XplZ19UVzzEdqN1YFq2fN1R10c3W3xdGNwgUe7YLo7rzbLX+imzXgyeuT3Zz4FHM20so14t2MAKvj0ymmbr4q0qWFlFhazZBPvuewt+Ozv+vz8BOXvR1v6u/ZH73Pz39t6xKOcHnxLZ1ohvrTjLM8XSmzCR0IBZBxA1plS810HWBsNzMGTUK+4Z3WDl0yIpLkay7lgzZ2c/JxZJse2ZY3FujHITWhLoBipNgqZhIfoD2n7EJdxL/Pgpm+aykpKS8HzUbIJ7/lsPfi1M37M7g5BTxbnx7IiCVys0zuDixQ2WLN0vxuVg2ortLNjnJza7Kbcw0Pu+VPd7Oc7OZ2yUImunm+0U6hrsW/zxIiLQ2xrpL03U8ZI4okz554SAkyUucdKeHkKKTdChN/Lw1uuwjB/s1iv04kKTAZnb12lYx2JOwhUUPLa2s5PNsgEmqGXKSp439xt0SrmEl+nUz6wWIx3JCbnxyzstOkfNBh/VmDrUc1REL6eL6esBI7gETVJk8amxBmdI42cv33pPfnZDU792ferNhjYu7NR3TScUEpKa8EUSh53nPzwJ/jo5B2O9nN5+GlGvHXc7OY4GYgNJZj93YSfTev59Si+oCbA1Nj526Z9pK62XQDbn58zMpOS7n5aYPNCW7O1d2Z3DxtBGOQ0Tlez467eS03dypxsxrv5kgXuLk0SfYqSd/9lDFazSi2hkNKqJ2E5PLjJ//Pfecr6RD4AbysydPXqhSPHcoHnbHGB4Gp4WaX55+fkzOw28HYcQK0Kraaz3enhNUJyDgBganTKSiZHN40OZSS9ad1sq3xx/Ds+NXUQUQYISQXWq+y9ryBFsr+8QipVrxLh53Ybsa9Fe+kI5WA1OBoa/oQ92zLRwqGBsBXjhzaZWuu1DffNjjazLOy2+oXWEW6YO9WaelmFKakpCyGViuKLbCUEuonIbnc8gdmV42bM3n2epVCkpszunLWMiAEbtbA6iS4uWypufZ3y6duzuj9QO/gZhGkZONJPdbvbtaYzc1AdIF9NNaeN9GiYTdn3JDiUSe+MVNS2U8XCUSamM3N7WDczYcd5eY5rj+8UTejdm73bhdTN18xy3OFnbJUJC2WJWWRpMHtOFLXqK/l8LImqy+aaF1RuLahxJNw8hORxGr7QHe38BKaQBxtFdh6WOtLp/cx790qnopNCNycGT8cXQiONwtYD2sIKdW4AgANDreSa3y0IGLteRO7+3r9jMbhjSLeOYN/LYjIeOONKHpNNuIC3GbZVg07Ri8eu3/axQxHNwpTm3IYXki2m07VQwBEkuKxw8nGdAnH0arYtEsWVscn0oSaq5sKNCXllUFOSiddwG6c/dH78LWLf9yrJuq72ei6WXnPWUo359l6VIORtY3dweaNU9zc83vfzaJ3e7KL9CBi9XkDu63Stf2MzuF2IXGe+6zoQYQ5wc1xAW6zYpFtJru5VcpwvDWbm+0YN8tIUjh25h7j16rYtIsWlpO6eZlIA9yUMXJ5LVaWQkCpPL6y+dX3vnQJR3XNkJJcwyNfc5Ga4LA7bifSxMRdymzTY+1ZY2ipcn+7iFM4Q31IJCmeOORrLghBo2LRKltTU3eeP6hQOHGwnADXNs7cAXD0MTxLPUZoJjxGd/SN6Z2OOMh4EZuPazx/rXrpKdxu3qRRtSkeO0O3H2wX6BQyMwvL8MLYXRbB+Wu7pCZw8vPVCqWkpFxv8gUdpD92uxBQjHHzeXkpS46kJF/3+vPED24UCM0Z3Fx3WXvRRApBryPC/s3i2c7H3UXOfH12N/uWwbMH1Yt3c9VOdqyUbD6qDY0fynghm4/VjPtzZVrNsRDj5EwaFZviSdfNXb8e3CjSKU5OSx7EdEOVTjxyDBoX4GY9dfOykQa4KWPoumBr22TnuT80V7xY0skXhk9s/z979x4l+X3Wd/7z/Ore3dWXufZcpJFkGQj2DgKM8QhnI4MhHhkwUWICOmAgLGLXYYWPlQVhn5AlC3tI4mQXDmyQd5k1BAJyIgxKbC4mEfEmYLAxlmUjY2xd5qqZ6futbr/6PfvHr7qnL7+qru7p7l919ft1zhxNd1VXPV2t6aee3/f7fZ6+L27dVVgKFUSRaqVcd7/Y3XXs0rwKlcaquWh1zR0qdbxCGISRjizP6Fv1C/jolXldeVWXScVdxy/OKV+7Nestdz1UabERX5nuIMoGtz23bSuPUaiEaxLoMnNp/MUZTZwqJ1+R7jKOej6j/Lo5vZFJC8Ptk9DMsUEtjBZVXIyvxFbK+S2PUQjzmcQkvvypoBnt6HYvAAdDJmM6fjKn6+ty8/BIJr4wfZBsOzfPqVAJV3LzwEJ903nimUZTR64ttHLzrV/uRy/P68q9Y939Pve181KlODcXlxqbThnY69xcXAqVCRNycySduM3c3MwFauQzyiXl5pE2TRjNNHN8UAtjrdycMVWGtp6bG/lMYr+RSIpXt8nNfYUCF4mGR7MqDQSam20qilxD5YyKpUC26kpZvxe32VpTxy/N3ppp6+pqeHdpobFS3Eq32vIPT1W0MNr+DObgXK3tYw7M17UwVtw05tJiY01xK8Vbf0oLdeWq4e0Nd3ePz/lUGsqErjAfaKlc2PbV3Gwjed6gSco24zcir5wZ2XbMEyfLGr8YN64wj8/YNgqZTX9+YT6jhdsY3xTmM6oO5FRcaqw55yPFRf2pL07rxh3D236DAODgGhnNamBNbs6qWLI1uXkn9PL25Fwt1LGLc3Fubq3IzRwuaX6T3+0D8/WV4lZaN7N0pP1uo4G59l2qB+brWhjtIjcv1NcUt1Kcmwfm65qrhWoUdi43N/KBKsOFbRdr2UZyw7Kdy81DOv7ynMzX5ubN5tDedm4uZFQr5da8P1s+21uohDr1pWldv2NY9RK5uR9Q4KKtXD7Q4aPJvyD7vbiVu45fmlMm9DVXGUcmK6qXsh23orSbWSrFA9oXR5N/QQetQmw9c90qsjdRWHe+ZM1zLzU2JiR35epNNTNBx0LVmlFrZXht4hu7vqTJE4NaGtk8wa+3WSMPc2lkYkkTp4cT4nENzVZVXGwozAVaGCtueIMQFjK68qoxDczXlW00VStmVd2ky6I1IxUroSJrdUDc5pvGiVNljd5Y1NBMLX4Ttep7kuJV+cv3jnFOB8CWdcrNO+G+86Ee7NXtya1V2MxyA8HW79TRyYrq7c6htmw2T3yxzQpiEEXJkwZcbTv/rrf+7OdqhaWEAvc2c7NfX4qP12xjRnptk8J1+aJA0q4wa0Yamq2t5Ob5sZLCwtpc3yhkdeXeMQ3M1ZQNI9VK2U2nE6zk5sC6ao7Vzs3TZY3dWNRgUm72WzvmyM37HwUutuzchbPSU2lHsbvy1eZKU6jVzKWh6WrHAjfKtOn4t8nM0spgTsOTlY2NFKzV/r4LzawpWtUhcO1ta5Pk4ExVh24sSd5qsFHKaeLUUOJV37EbSxu2+7a+JR1+ZVHVwfyWV3IbhbjgbJf44xm8G68kB81I4y/NKhNGK9vMhmZrmjhZVmXdLDsPrO2blvWGpisau7HUSmwuN9P1O4a3dZXaA9P0+JDytaaKlY1ne8xd+WrztptpAcBBUqiEa7rjLzOXytPVjgVu1JpZmpibO2x3rQ7mNTxV3VjkmuKLpl1oZoPk3Gxx3l5tfW6uDOQ0cXLoVlOpVQ5dX2ybm49cW9CVwdyWV3IbxeyGXUjrHztX25jXgmakEy/OKmiuzc03T23sI+KBabGLlW9JGpqqaOzmrdwcmenGbeTmqfEh5auhCtWk9xeuXK15e7vd0BPYbI4t66u5eG2sbH1axxT/AuxkYWTjXDRJcpkqHQrjeimnpXJ+zdD2yKTF4ULXv2wXE1ZSXfG81MqqBFNYaujQ9UUFUdxV0Ty+gn3kynzi4w7O1ToOWB9YaL+Fq5Obp8qaPVRM7Dvhiuf8rTc8WVkpbqXWz8Slw68sbHtofb4aauzGkoLWankQxT/n45fmtv2YHe3CQwLATngweDTtENqyKL74uOHzigusThZGCx1yc/tCtVbKamkoITePFLreWtwxN696X1BYTMjNiw0dvbKQELhrcL7eMTeX5reZm0+XNTfWPjcnfd/DkxUFCbn5yLXbyM2VhsZurs3NmdY26dvJzRsvkaDfUOBiS/p+a3JLrZRNLEIik5Y6NCmS4q2xU+ODikxqBqYoMDUzFs9F26QpwuSJIU2cLGuxnNNiOa+bp8pdzXZbiS8b6MYdw2pm4pXcyOKZu9fvHF7TkCFppXj5HEpm/fkbT946vfY+XYe47klNc0cHNT9WWPPmQYpXrpMaf5Tmk4e+WxRv6dqOoZmNV+fj81m+MsJoOxZGN35fUnwVuWdmLQLAPlErZWUJhU2cmzvv1mkU4pmlUWvFdiU33zncOTebafJkKzcPrcrNx7vPzc1coJunk3Pz6ucemapsyG+BpEKlsTE3S5vm3m2XcWaaPTaYmMPc4n4k6w3M1RKLCotc2Xrniw/tlGdqibk5iOImY9u1OJJPzM1RxtRIuLCO/Yc1eHTtoBS3UmsbS2t4t7UWcyOLu/AlXYldb3GkNRdtqSHfynlOizv3rt9quxW1gZwu3zumXC0eV9PIZzY8dzahQ+Ly82fCaG0jLLOVrcTtvoMwazp8dV6ZMNLSUF6Lo8UtdTicPjaoZibQ8HRVQdNVL2Q0fXxwzcp10Ix06NqCco32Gd0i19grCyotNtTMBZo9VOpqxFLSdvRbt7my9aYGZ2sydy2V813PuVscLmhgvh6/dq1mGrJ45ZozPgCwNZ4JNH1sUGM31uXmQkYLXZw3XZ5ZWqw0ttZrYQdyc3XwVm52a3XcX/fcmTbNF2XxymVz9UKzmaoDWRWXwrb5qxlYPJ2hGWmpnNfiyNZy89TxQYXZQMNTVQWRq17MaCohNx++tqBs2D43B03XoVcWVs7mzh0udTVWp21utrjIzdaa8Q6z5dzcZYOohdGiSgsNFZfIzf2KAhddOUjF7bLF0aLqxazK01Vlmq3CbbjQ9XB3D2xr82t3klnHbc2VwdyGNv2SJPfErUdTx+Nh88tnn5bTmLce6+jVhZU3G4VKqPJMTa/cNdJ9IjXT3JGBjh2Oj12aU76aEHMrjkY+0LFL83GzLkm5RqR8ZV7Txwa0MNa5O+NSuaDSQsJ5I49HRJy4trByFbk8XdXicCFeWd8sEZrp5qmyCpVQhUqoKGNaLOcTz1IBQNqefOJh6em0o+hsYayoeimroeXcXC5osZzvPjdn1h7Z2VOb5ObqQE65elJubl2sXmdqfEjjL82u5L31ufnItbW5eWimplfOjHT9Wm2am911rNXkql1uruczOnZ5bk1uLlTmNX1scNPpEEvlQnKfDpey9VBHrs6vyc0LIwVNH+8yN59u5ealhqJsQG7uM6kUuGZ2SNKTku6S9JKk73T36YT7vSRpXlJTUujur9u7KLHsIBa3yxrFrKZODKUdxo6bO1TS0GxtTbOOyKSZI6XEojTMZ3TlntGV7ogWuWrFjCrlgo5fmtsw+iDbaGpwpqqFVtv/wdk5fdmnn1V5Zkav3HmHXnjNaxTmu2/Fn6uGiQX58tM28oEahazytbXnkQKPG2QtjBQ7JvSlcl7l6azy1VvzEd2k2UNFjU6s3TJmHp9JXhwpdDfqx0y1Tbp7Ar2A3Iz9ot6vuflwSYNztZViUFrOzQNtc/PVV41qcLam4mJdFkm1YkZL5YLGE3Jzrt7U0Gx15aLv4OysvuzTn1F5dkbX7rxTL7zmK9XMdZ+r8tVmYkF+KzdnFOYzKqzL34FLYzeXtDBa6FiMLg7nNTQdz7Rfm5tLibl5aLampWFyM9JbwX1c0n9y9581s8dbH/94m/u+yd0n9i40rHb/c49Jj1fSDgM7LMoGunbXqIYnl+LtvNlAc4dKHbdfZZqu6kBO82PFlYRUXKxrzWXjluX5fguHSjp+6bK+6d//loJmU5ko0ukvvaDX/ukn9OHv+x7VSp1XVpdlG83E54m7P2d0/c4RnXxhpu1Wplx9k66IZrp+57AG5+oamKspypgWRovtZ/V6fN6IxIg+Q24+wM5dOKv3PDWadhgHWjMX6NrdIxqerHSdm4Ok3LxQj/++7rzySm4eK2n85Yv6xt/6kIJm1MrNL+q1f/YJffgd36N6sbsOx51m5lZKWd24c7h9bvb4+E/YqVGXma6fGdHgXE0Dc/WV3Nyu34a1vj9yM9IqcN8m6YHW339F0h+pfRJFSs5dOKsHKG73RLbWVHm6omwjUnUgF3d73OWtMs1coOnxIW1Ynlkn02jq6JX51pneOE1Njg9qabigKAgSm1y44iJa7vqGD/+uco1bjZpyYahgYUH/3R9/XJ/8pjdtGmem0VSu2pQl1JqRKe5AaaYwFyiXUJCabxyRlMjikUKrxwpl5mod779VQRhpcK6mTBj/nDebywvsMXLzAWZf983SU+T81XK1UEPT1Tg3D+a0MLIXuTnTfW6+PL9S7LmZJscHVRkuxCMJE5pxuVr50F1v/PDvKte41agp12jI5hf02o//mT71wH+/aZyZelPZWjOxCWVkireBm6mZbZObpe5GGJlpcaS4pv9Ju4vPkhI7ZW+G3Nx/0tpsftzdr0lS67/H2tzPJf2Bmf25mT2yZ9FB5y6cPRDjgHpBcaGuEy/NqDxT08BiQ6MTSzr54qyCcHtdB3eU+8rZ11tt+l2Hry0oVw1VL2bUzAYbalw3aX6sqMG5OdWKZU0fHle0KllkokhnvvDXmz59ebKiky/MaGQqftO1+nlc8Tnn5TM8c4dKG7oiRopnCG51Ru+ydqMjvDUiYivylYZOfWlaozeXNDJV1dEr8zp+cU6KmBmEnkFuPsC4oL1WaaGu8Zdmb+Xmm63cvMk4oj3hruOts6+Bxyuzmch15NqCcrVQ9WJ2Ze7vmi+zuMHS0MyMKoMjmjl8fE1uzjabuuuvvrDp0w9PLOnki5vk5tE4R84dTsjNFufXbefmoQ65uYtmY6sVltrk5t0YEYg9s2sruGb2h5LGE2567xYe5hvc/aqZHZP0UTP7vLt/rM3zPSLpEUk6nutu2yOSUdzuIY+LxfXnZCyMNDJZiZslpChfDZVtbOxiaB43dJg6MaQbdwzr2KU5ZcJIbiZz18zRAVnkOvRKqOe/9m+1vsb1mk88o7HJVyRJ4SbnfHLVUKMTSxuaS6z+sDKQU9Q6l1Qdymv62EA8EL51x+pAThMnt39OyzOBJk6WdeTq2vnAs4dLcSflrh/IdfTKxp9zvhqqPF3VfMLIBWA3kJuBLrTJzQojDU9WNHMs5dxcCZVJmIawkpvHh3T9juG4R0YUyRXn5ulWbh67Een5r7mVm1/7Z/9Zo1PXJW2em/PVUCOTG8cZrcnNg7mVM8OVobymj7Zyc+uoUXUwp4kT5W1//1Em0MSJoXjG7iozR0qdjyOt5x53mW6Xmw/xO2u/2rUC193f3O42M7tuZifc/ZqZnZB0o81jXG3994aZfUjS6yUlJlF3f7+k90vSV5RGueyyTRS3eyvbiBQkrOCZ4qvHqRa47hq7sZS4/ch06+xNmM/o6j2jcYOmprfmFEqnvjStwKVm7tbZoee+/pt07qP/TvJIn//q+zo+fdz6P/m5lw0s1FWdq6+spi6MlbQwEp/PaWaDbV8dXq1SzuvKvWMqzddlHl85XjNGqQu5ejPxqn/g0tBcjQIXe4bcDGwuW49kCbk5UHzGM9UCd5PcvDxqKCxkdOVVa3Nz4NLJpNz8hjfr3B98UC7fPDfPdpGb5+uqDNVXZhMvHCqtnJ3dsdw8XNCVwdzt5eZaM/E9WNBqJkmBu3+ltUX5aUnf1/r790n6nfV3MLNBMysv/13St0j67J5FeABR3O69KLC28+u2MqtuNxQXG8pXkufrrZx9XWameimn6lDcZn+ww9nV66fv0aVX36svfPVXdXz+pAS6XtC6Wr32k/EYhp1IoMuiTKDF0aIWxopbTqCS5G1/yolHmIG0kJsPqCefeDjtEHqKd0gfUSbd3FxabChfbZ+bq6uP1qzLzQOz1YSvivPQ9dN36+Uv/zJ94b6znQPoYuvufsnNHVLzZjeix6XVZOpnJX3QzH5Q0kVJb5ckMzsp6f9x9wclHZf0IYvPBmQl/Vt3/72U4u17FLfpiLKBasWsCusKycikuU3mw+22gfl64hWw9edrkgSRJzeeyGT1mTec0807DrV/YneVFhqSu1ybp5ikq+y9JswHamYD2brt3pGp4+sI7DFy8wH17NN0T16tmcuo3iY3z28yV323DczV2ubmKIi7DLfTKTc/e/836ObpzXJzvFraL7m5kc8oygQbep6Qm/e/VApcd5+U9E0Jn78q6cHW31+Q1HmJBzvivvMhxW2Kbp4q6/jFuZVROOba0M03DW6WmMRc0vTRgY6dJKsDOQ1bZUMijQLT7NHhtl8XhJHGX55VphmtdE1e/RDrY4ksnpPX88xWfs4ml0Xx91UtZbWQ8s8ZWEZuPpjuOx9ufqcDaOJkWccuzSrbiOSt3LwwWkg953TMzccGO+7+qg7mNTxVTczNM0e6yM1htPK1/ZKbb5xu5Wb3leK9WspqYT/Ej7bS2qKMHvIT3/GOtEM40KJsPPfu+p0jmjhR1pV7RjU1PpR6i/rF0UJyu33TyrmadmqlrCpD+TWdEyOTlsr5js2ZDl1fbJ1LjhPm8pc38oEWy/HjLSfVyKQwl9k3Z2Qaxayu3DumqSODauQDmaRiJdTJF2dVWGps+vUAsBs+/2PfmXYIPSmeSTuq63eOaPJEWVfvGdX08fRz80K73Byo47xcKc7N1cHchty8OFzo2Jzp0CsLcW727nJzI5/RQsor3d1azs3TRwfUyMW5udTKzfkKuXm/SmuLMnpE8ZmH9Oz72JqUOjPVS731z7FezGrmyIDGJpbixNXqfnjz9PDm5zyZ5KoAACAASURBVIPNNHFySAPzdQ3OxudxF0YL8Vy8dtw1sFDf2BVSUq4R6do9Zc3UmxqaqSobRqoO5rVYzkspn1UuLDU0PFmJYxrIae5QSc1c8rVDN2l4tqpcPd6qbC4FjUjHLs3p6j2j2ztDBADYHb2Ym0s5zR4uaWSyNdaplZtvnOouN988VV6Xm4ttx+5IauXmRmJuzrZy82y9qcHVuXk4n/qFgMJiQ8NTcW6uDOQ0f7gUzwBO4CaVZ6rKLR8j8vh9x/GL5Ob9qrf+1WJPFZ95SO9+X9K0CCA2f7ikpeGCiot1eWCqDOW7b35lpqXhwqarvWtscmSnmc9otkP3ykwj7nwZ5oM9Sa6Ds1UdemVR1rqqnas1NThb07W7RxITYr4aKltvth3tkPboCQAHD+8D9p+5IwNaHCmouNjYm9y8ibDXcvNMVYeur83NQ3M1XbtrNPECdKGSPBJRLg3N1DR7dGDXY8bOosA9oChu0a1mLu5SuOvMtDSU23Cl2CUttTo2B81IgzM15Wuh6oWsFkcLKw0ijl6ZV74anyXzwDR5YqjzivHtctfY9bVzek1xE4+RiYqmTmycv5ttbBwVtPx1uXpzd+IEgDbOXTgrPZV2FNiOZi6jxdE9WFk0U2Uop1JSbi6vzs1V5WtN1YtxbwnPBMo0Ih25Mq987VZunjgxpOou5+ZDNxJyc9M1PLmk6fE2ubm1Er5aIHLzfsUZ3AOI4ha9anp8KJ6Rp1a3ZsXNL6aPDShbb+rkl2Y0OrGkobm6RieWdPJLM8rWQh2/OKdCJVTg8XiCTDMe3p6r7V7zlGw9kiWMSzBJxTZnatudP44sbswFAECvmTo+qGbW1uTmZsY0c2R1bq7Eufnmkk69MKNMPdSxS7MqVNfm5qNX5pWt7V7RGBekybm5tJicm2vFbOIOssjihlPYf/ipHTAUt/ucuwbm6xqaibsgLpbz8UiAbZ5DzdaaGp6uKFtrqjaQ0/xYcUdn1G1VMxvoxqkhjV+ck5abWbhr/OKcGrkgHnHQum/gkrvr8LVFZRvJ236HpquJV2t3QpRpP8O42abDdJjPaGkor4GF+srVZW89Ft2UAew1JijskPW5ebiVm7e5HTdbCzU8Xe2d3JzL6MbJssYv3crNQeQ6fmlOYdY25uam68i1xcRtv8tHcqbHd+dITjMTJI5CktT2DG5YyKgymFdpcX1uDrQ4ku7IRmwPBe4BQnG7/x26vqjB2drKL+B8NdTgXF3XzwxvOZEWFhs6dnlu5YxKoRqqPFPVtbuSz4/ulcOrzrRKcbK0MIrHE6y773LcUaANV193e9tvlA1UGcypuNBYsxUmMmnucPuEOHlySPXpqsrTVVnkqpTzmjnSeewSAKB3HXplUYNzCbn5zq3n5uJiXUcvz/dcbj7yyuKabb+BS9aIlG1sHBNkis+1epvcnG3sbm6ulnIqLCXl5vadnSdODak8VVF5piaLXEvlvGaPDMgz6TbLwvZQ4B4QFLf7X7beXFPcSnGCyddClRbqqpS30szJdfiVhQ2P5U3X6M0lTZ4s71zgW2DNSPlawmqs2vefWp5PuF5kUmWw+3M+haWGRm8sKV9vKswGmj1S2rQJx8SJIR29sqBCpbES5MyRUuefhZnmD5X2zXgjAEB7uVq4priVWrm5Gqq02NhaL4jWrqTE3DxR0WRCb4e9EDSjxAvG283N1cHuj+Tcys2hwmxGM0cHNh2HNHFqSEeuzKtQCVfl5oHOPwszzR8e0PxhGkr1AwrcA4Ditj+0O9cZeHyuZCsFbtB0ZcONDY86nVGR4mHvQzNV5epN1UpZLY4Uu+/c2I0OV7qXz/2svyK7OFxQFEjlmVtvMCLFW4sWRrt7TQpLDR27NHfr6nu9qcPXFmSRd2yw5ZlAN+4cVqbRVCZ0NQqZnX09AGCXPPnEw9LTaUex/xWWkns9BC4Vt1jgZkJX0EzOzcWFeoevi5s87VZu7jTgoF1uXhgpyKQ1F+YjxduEF7rc9puUm49cndfU8cGOuTnKBLpx5wi5+QCjwO1zFLf9o5mxxMulcbOHrW1v7fSLPmpzW74a6vjFWanVLGJgvq6RyXjb1E6dDfLAVB3Mqbi4sVujrfr78lzeRiGj6WOD8kBqFHMqT1cUNOOtRXOHSl1v+x1d13FRir/HsZtLWhwpbLrFrJnLqEmPKAD7yLNPj6YdQl+I2mxhjdTK21t5rGDjdt9l7bbK5iut3KxdzM2ZQNWBrIpLYVe5uV7MaubYoNykWimn8lRFQWvb79zhUtfbfsduLCbm5lFyMzZBgdvHKG77S2UwL5fJ5WsTTOtK6VZ4YFoajNv+r7/qOj+WfFX08LUFBasuLC+fjR29uZQ4Eme7Jk4MafzirDKN6FajqYT7TR4fiJs/tBLc4kghTnjbkG9zVjdouixyzuAAABJVhvJyM2l9V33TlnOSZ+LeDutH8kQmzbXNzfMbz8aGkUYmkkfibNfkibKOX5xVJtwsNw+uKT5vJzfn2nRbzjRd5vH7HyAJXU36FMVtHwpM1+8cjsfoWHyltxmYJk6V1cxvvfHE5Ikh1UvZ1mPZynbfpAI3aEaJicYkDXTYNrUdUTbQ1btHdfP0sBbGCm0TWKHS3LGB8WGbq9wedF7tBoD96P7nHks7hL7hrdwcZm1Nbr55qrytplCTJ4ZUK97Kzd4qlBcStuQGYaRcwnx1U7ySu5OauUBX7xnVzdPlODe3uV++Gu5cbs61y81GcYuOWMHtQxS3/atRzOrKq0aVqzVl7vFc1W0mEs8Eun5mRNlaqGwjUqOQVTNrytWa8sAUriqavdPZ2B1KZGtYvFXZokhD07WNN0sKwp3rwjhztKQjV9c23YqvmJd2LFEDQK/41MSLknifsFPi3DymfK0p3WZujjKBrt81olwtVKYRqVHMqpkx5WtNRRtys9oekN2Vi7Nmqg7mFTS9bW7OJJwh3q7ZIwPx7rF1uXn20PZHMOFgoMDtMxS3B4CZGsWd+6cbFrIKC1Jpoa7DLy7IWtuswlygm6eHFebj5gzVgZyKSxu3Tc132chpOxr5TOIWqOX5dDulUi5o6rhr7OaSgqbLg7i4nT1Cp2MAQBfM4sJ2hzQKWTUKUmm+Hjc9lCR3hfmMbp4qx7m5zdnYyNR1k8XtqHfIzc0dLKyXhguyaF1uPlTqOO4HkChw+wrFLbYrW2/qyJW153hy9UjHL87pyqtGJTNNnBzS8Yuzyq7aDlUdyO1qosk1osRRAyYldoG+HYujRS2OxMnUA+PqMIC+dN/5UA/yXmFfyNZCHbm6LjfXmjp2aU5X74lz8+TJtWdjpXgMz9wujqLrnJs79VzeuuXcHEQeN8EkN6MLFLh9guIWt2NoupqYqIJmpOJSqOpgTlE20LW7R1WohMrWm6oXszu6kpykXXdol9TM7sLAezMaSgEAekJ5upaYmzNhpEIlVG0gp2arb0VhKVS2sTe5uV3naFd8VnfHmbV9TiAJBW4foLjF7cqGUfJoAoubWNz62FQbyKk2sDd99+vFjJrZQNaINnSOnj/U3Rw9AAD2o2zYbJubM+tz82BONe1Nbq6Vsu1zc4f5tMBeoYvyPkdxi51QGcwpanOgpjaQ4nUwi7tTNgqZle6UUSBNjg/u6FknADgoBv75j6cdArrUMTeXUs7NdwyrkV+dm02T44O7vnoMdIP/C/cxilvslMXhgoanqso2mitnfaLWfN3tjDnYSc1cRtfuHlW21lQQRaoXshKjewBgWx54vJJ2COjS4khR5emqso1oTW6eH+2B3JzP6No9q3LzbXSOBnYaBe4+RXGLHRWYXrlrROWpigbn64oC0/xYUUvlfNqRrQgLGUnpJnQAAPaKB6ZXzoyqPE1uBraCAncforjFbvDANHdkQHNHBtIOBQAASPIMuRnYKs7g7jMUtwAAYDvuf+6xtEMAgF1HgbuPUNwCAIDt+tE/vpZ2CACw6yhw94H7zocUtwAAAACwCc7g9rj7zod6MHhUel/akQAAAABAb2MFt4etFLcAAAC34dyFs3r26dG0wwCAXUeB26MobgEAwE6xr/vmtEMAgD1BgduDKG4BAAAAYOtSKXDN7O1m9jkzi8zsdR3u9xYz+ysz+6KZPb6XMaaF4hYAkAZyMwCgH6S1gvtZSQ9J+li7O5hZRtIvSjov6SslfbeZfeXehJcOilsAQIrIzX3sgccraYcAAHsilS7K7v68JJlZp7u9XtIX3f2F1n1/U9LbJP3lrgeYgve89Z1phwAAOMDIzQCAftDLZ3BPSbq06uPLrc/1HYpbAMA+cWByMwBgf9q1FVwz+0NJ4wk3vdfdf6ebh0j4nHd4vkckPSJJx3OlrmLsBRS3AIC9Qm4GAPS7XStw3f3Nt/kQlyXdserj05Kudni+90t6vyR9RWm0bbLtJRS3AIC9RG4+mM5dOCs9lXYUALA3enmL8ickvdrM7jazvKTvkvR0yjHtGIpbAMA+1Ne5uV+96ak3ph0CAOyZtMYE/R0zuyzpnKQPm9nvtz5/0sw+IknuHkr6EUm/L+l5SR9098+lEe9OevKJhyluAQA95yDnZgBA/0iri/KHJH0o4fNXJT246uOPSPrIHoa2q5584mE9+/Ro2mEAALDBQc3NAID+0stblPsKxS0AAAAA7C4K3D1AcQsAANJQfOahtEMAgD2Vyhblg+LchbN6V+O1FLcAAAAAsAcocHfJuQtn6VoIAAAAAHuILcq7gOIWAAAAAPYeBe4Oo7gFAAC94t3vG087BADYU2xR3kHvees7pafSjgIAACC+6M77EgAHDSu4O+Q9b31n2iEAAAAAwIFGgbsDKG4BAAAAIH1sUb4N950P9WDwaNphAAAAbGBf983SU5W0wwCAPUWBu02s2gIAgF72wOMUtwAOHrYobwPFLQAAAAD0HgrcLaK4BQAAAIDexBblLhWfeYhZcgAAAADQw1jB7QLFLQAAAAD0PgrcTVDcAgCA/YYjVQAOKrYot7EyAuh9aUcCAAAAAOgGK7gJmG8LAAAAAPsPBe46FLcAAAAAsD+xRXkVzqsAAAAAwP7FCm4LxS0AAOgH9z/3WNohAEBqKHBFcQsAAAAA/eBAb1HmvC0AAAAA9I8Du4L75BMPU9wCAAAAQB85kAXuk088rGefHk07DAAAAADADjpQW5TPXTirdzVeS3ELAAD60n3nQz3weCXtMAAgNQemwL3/ucf4hQ8AAAAAfSyVLcpm9nYz+5yZRWb2ug73e8nMnjOzT5vZJ7f7fBS3AAB0tte5GQCA3ZDWCu5nJT0k6Yku7vsmd5/Y7hNR3AIA0JU9y80AAOyWVApcd39eksxsV5/nPW99p0RxCwDApvYqNwMAsJt6vYuyS/oDM/tzM3uk2y8aGPG4uAUAADttW7kZe4MRiAAOul1bwTWzP5Q0nnDTe939d7p8mG9w96tmdkzSR83s8+7+sTbP94ikRySpMHxUb9hW1AAA9K80c/PxXGlbMQMAsBW7VuC6+5t34DGutv57w8w+JOn1khKTqLu/X9L7Jal84tV+u88NAEC/STM3f0VplNwMANh1PbtF2cwGzay8/HdJ36K4AQYAAEgBuRkA0OvSGhP0d8zssqRzkj5sZr/f+vxJM/tI627HJf1XM3tW0p9J+rC7/14a8QIA0O/IzQCAfpBWF+UPSfpQwuevSnqw9fcXJH3VHocGAMCBRG7e/4rPPCS9L+0oACBdPbtFGQAAAN37lS8U0w4BAFJHgQsAAAAA6AsUuAAAAACAvkCBCwAAAADoCxS4AAAA+9x950M9+/Ro2mEAQOoocAEAAPa50tu/Ju0QAKAnUOACAAAAAPoCBS4AAAAAoC9Q4AIAAAAA+gIFLgAAwD73pqfemHYIANATKHABAAAAAH2BAhcAAAAA0BcocAEAAAAAfYECFwAAAADQFyhwAQAA9rHiMw+lHQIA9AwKXAAAgH3s3e8bTzsEAOgZ5u5px7DjzOympJdv4yGOSJrYoXD6Ea/P5niNOuP12RyvUWd7+fqccfeje/RcfYvcvOt4fTbHa9QZr8/meI0664nc3JcF7u0ys0+6++vSjqNX8fpsjteoM16fzfEadcbrc/DwM++M12dzvEad8fpsjteos155fdiiDAAAAADoCxS4AAAAAIC+QIGb7P1pB9DjeH02x2vUGa/P5niNOuP1OXj4mXfG67M5XqPOeH02x2vUWU+8PpzBBQAAAAD0BVZwAQAAAAB9gQK3DTP7F2b2eTP7jJl9yMxG046pl5jZ283sc2YWmVnq3dJ6hZm9xcz+ysy+aGaPpx1PrzGzC2Z2w8w+m3YsvcjM7jCzZ8zs+da/rx9NO6ZeY2ZFM/szM3u29Rr9VNoxYe+QmzsjNycjN3dGbu6M3Ly5XsvNFLjtfVTSa939rKQvSPqJlOPpNZ+V9JCkj6UdSK8ws4ykX5R0XtJXSvpuM/vKdKPqOR+Q9Ja0g+hhoaTH3P1vSHqDpH/I/0Mb1CR9o7t/laT7JL3FzN6QckzYO+TmzsjN65Cbu/IBkZs7ITdvrqdyMwVuG+7+B+4etj78uKTTacbTa9z9eXf/q7Tj6DGvl/RFd3/B3euSflPS21KOqae4+8ckTaUdR69y92vu/qnW3+clPS/pVLpR9RaPLbQ+zLX+0EzigCA3d0ZuTkRu3gS5uTNy8+Z6LTdT4HbnH0j63bSDQM87JenSqo8vi1+A2CYzu0vSV0v603Qj6T1mljGzT0u6Iemj7s5rdDCRm9ENcjN2DLm5vV7Kzdm0nrgXmNkfShpPuOm97v47rfu8V/HWhF/fy9h6QTevD9awhM+xsoQtM7MhSU9Jepe7z6UdT69x96ak+1rnLz9kZq91d86O9Qlyc2fk5i0jN2NHkJs766XcfKALXHd/c6fbzez7JH2rpG/yAzhPabPXBxtclnTHqo9PS7qaUizYp8wspziB/rq7/1ba8fQyd58xsz9SfHaMArdPkJs7IzdvGbkZt43c3L1eyM1sUW7DzN4i6cclfbu7L6UdD/aFT0h6tZndbWZ5Sd8l6emUY8I+YmYm6ZclPe/u/yrteHqRmR1d7pxrZiVJb5b0+XSjwl4hN2MbyM24LeTmzfVabqbAbe8XJJUlfdTMPm1mv5R2QL3EzP6OmV2WdE7Sh83s99OOKW2txic/Iun3FTcg+KC7fy7dqHqLmf2GpD+R9OVmdtnMfjDtmHrMN0j6Xknf2Pq982kzezDtoHrMCUnPmNlnFL9x/ai7/8eUY8LeITd3QG7eiNy8OXLzpsjNm+up3GwHcHcPAAAAAKAPsYILAAAAAOgLFLgAAAAAgL5AgQsAAAAA6AsUuAAAAACAvkCBCwAAAADoCxS4wAFmZr9nZjNmxpgVAAB6ALkZuD0UuMDB9i8Uz3YDAAC9gdwM3AYKXOAAMLOvM7PPmFnRzAbN7HNm9lp3/0+S5tOODwCAg4bcDOyObNoBANh97v4JM3ta0k9LKkn6NXf/bMphAQBwYJGbgd1BgQscHP9U0ickVSU9mnIsAACA3AzsOLYoAwfHIUlDksqSiinHAgAAyM3AjqPABQ6O90v6x5J+XdI/SzkWAABAbgZ2HFuUgQPAzN4hKXT3f2tmGUl/bGbfKOmnJH2FpCEzuyzpB93999OMFQCAg4DcDOwOc/e0YwAAAAAA4LaxRRkAAAAA0BcocAEAAAAAfYECFwAAAADQFyhwAQAAAAB9gQIXAAAAANAXKHABAAAAAH2BAhcAAAAA0BcocAEAAAAAfYECFwAAAADQFyhwAQAAAAB9gQIXAAAAANAXKHABAAAAAH2BAhcAAAAA0BcocAEAAAAAfYECF2gxs8+Z2QNtbnvAzC53+NoPmNlP71pw+4iZlczsP5jZrJn9uy183Z1mtmBmmd2MDwAAAP2LAhcHgpm9ZGZvXve57zez/7r8sbu/xt3/aM+D62B9jPvE35N0XNJhd397t1/k7hfdfcjdmzsViJndZWbeKpyX//zjVbebmf0zM5ts/fnnZmY79fwAAADYW9m0AwDQu1rFnrl7tIUvOyPpC+4e7lJY2zHaJp5HJH2HpK+S5JI+KukFSb+0h7EBAABgh7CCC7SsXuVtbbP9gJlNm9lfSvq6dff9ajP7lJnNm9mTkorrbv9WM/u0mc2Y2R+b2dl1z/OPzOwzrW28T5rZmq/vMt4fMLPnWzG8YGY/vOq2z5rZt636OGdmE2Z2X+vjN7TimjGzZ1dvzTazPzKznzGz/yZpSdI9Cc/9N1r3m2lt7f721ud/StJPSvr7rdXSH0z42teb2SfNbM7MrpvZv2p9fnm1NWtm59atulbN7KXW/QIze9zMvtRadf2gmR3a6uvX8n2S/qW7X3b3K5L+paTv3+ZjAQAAIGUUuECyfyLpVa0/f1txISRJMrO8pN+W9G8kHZL07yT93VW3f42kC5J+WNJhSU9IetrMCqse/zslvUXS3ZLOantF1Q1J3yppWNIPSPo/Ws8tSb8q6XtW3fdBSdfc/dNmdkrShyX9dCv+fyTpKTM7uur+36t4dbMs6eXVT2pmOUn/QdIfSDom6X+W9Otm9uXu/k8k/e+SnmxtN/7lhLh/TtLPufuw4tf3g+vv4O5/0vr6IUljkj4u6TdaNz+qeNX1b0k6KWla0i92fKWkl83sspn9v2Z2ZNXnXyPp2VUfP9v6HAAAAPYhClwcJL/dWnGcMbMZSf9Xh/t+p6Sfcfcpd78k6edX3fYGSTlJ/6e7N9z930v6xKrbf0jSE+7+p+7edPdfkVRrfd2yn3f3q+4+pbhYvG+r34y7f9jdv+Sx/6K44PybrZt/TdKDZjbc+vh7FRfkUlz4fsTdP+Lukbt/VNInFRfByz7g7p9z99DdG+ue+g2ShiT9rLvX3f0/S/qPkr67y9Abku41syPuvuDuH9/k/j8vaVHSe1sf/7Ck97ZWXWuS/ldJf8/Mko5cTChefT8j6WsVF+y/vur2IUmzqz6elTTEOVwAAID9iQIXB8l3uPvo8h9J7+xw35OSLq36+OV1t11xd29z+xlJj60rpu9ofd2yV1b9fUlxobUlZnbezD5uZlOt53hQ0hFJcverkv6bpL9rZqOSzutWYXdG0tvXxfdGSSdWPfzq7329k5IurTuX+7KkU12G/oOSvkzS583sE2b2rR2+xx+W9ICkh1c93xlJH1oV+/OSmoobW63RKqA/2SrUr0v6EUnfsqrwX1C8Ar5sWNLCup8tAAAA9gmaTAHJrikuSj/X+vjOdbedMjNbVQjdKelLrb9fUrz6+zO7FVxru/NTkt4h6XfcvWFmvy1p9crjr0j6HxT/O/+T1hnT5fj+jbv/UIen6FTgXZV0h5kFq4rOOyV9oZvY3f2vJX23mQWSHpL0783s8Pr7mdnflPS/SXqju69eZb0k6R+4+3/r5vnWP/3yw7f++znFDab+rPXxV+nWzxwAAAD7DCu4QLIPSvoJMxszs9OKz5ku+xNJoaRHWw2RHpL0+lW3/9+S/kcz+3qLDZrZW82svM1YzMyKq/9IyksqSLopKTSz85K+Zd3X/bakr5H0o4rP5C77NUnfZmZ/28wyrcd8oPV9duNPFW8Z/rFW86oHJH2bpN/s8pv5HjM72iqOZ1qfbq67zx2SnpT0DndfXzj/kqSfMbMzrfseNbO3tXmurzezL281pjqseLvzH60qmH9V0rvN7JSZnZT0mKQPdPN9AAAAoPdQ4ALJfkrxttsXFZ9tXT6/KnevK155/H7FDY7+vqTfWnX7JxWfw/2F1u1f1O115r1fUiXhz6OKC/FpSQ9Lenr1F7l7RfEq793r4rsk6W2S3qO4QL4k6X9Rl78PWt//tyve9jyh+CzzO9z9811+P2+R9DkzW1DccOq73L267j7fJGlc8erucifl5ZXVn2t9r39gZvOKG1B9fZvnukfS70mal/RZxWehV58VfkLxGejnWrd/uPU5AAAA7EPGUTOgf5nZT0r6Mnf/nk3vDAAAAOxznMEF+lRrNuwPKu6gDAAAAPQ9tigDfcjMfkjx1uPfdfePpR0PAAAAsBfYogwAAAAA6Aus4AIAAAAA+gIFLgAAAACgL/Rlk6nRbN7HcwNphwEAfW1gxPXXdiztMHbdwitfnHD3o2nHAQAANteXBe54bkAX7n1j2mEAQN+673yoB4NH9bVpB7IH/ss/e+vLaccAAAC6wxZlAMCWPRg8mnYIAAAAG1DgAgC25P7nHks7BAAAgEQUuACArt3/3GN64PFK2mEAAAAkosAFAHSF4hYAAPQ6ClwAQFcobgEAQK+jwAUAbOo9b31n2iEAAABsigIXANARxS0AANgvKHABAAAAAH2BAhcA0BartwAAYD+hwAUAJKK4BQAA+w0FLgBgg3MXzqYdAgAAwJZR4AIA1jh34aze9NQb0w4DAABgyyhwAQArKG4BAMB+RoELAFjxF3ffm3YIAAAA20aBCwCQJBWfeUjvft942mEAAABsGwUuAIDiFgAA9AUKXAAAxS0AAOgLFLgAcMAx7xYAAPQLClwAAAAAQF9IrcA1szvM7Bkze97MPmdmP5pwHzOznzezL5rZZ8zsa9KIFQD6Fau3AACgn2RTfO5Q0mPu/ikzK0v6czP7qLv/5ar7nJf06tafr5f0r1v/BQDcJopbAADQb1JbwXX3a+7+qdbf5yU9L+nUuru9TdKveuzjkkbN7MQehwoAfefchbNphwAAALDjeuIMrpndJemrJf3puptOSbq06uPL2lgEAwC24NyFs3rTU29MOwwAAIAdl3qBa2ZDkp6S9C53n1t/c8KXeJvHecTMPmlmn5xp1nc6TADoCxS3AACgn6Va4JpZTnFx++vu/lsJd7ks6Y5VH5+WdDXpsdz9/e7+Ond/3Wgmv/PBAkAfeFfjtWmHAAAAsGvS7KJskn5Z0vPu/q/a3O1pSe9odVN+g6RZd7+2Z0ECQB958omH9ezTo2mHAQAAsGvS7KL8DZK++rM9aQAAIABJREFUV9JzZvbp1ufeI+lOSXL3X5L0EUkPSvqipCVJP5BCnADQFyhuAQBAv0utwHX3/6rkM7ar7+OS/uHeRAQA/YuRQAAA4CBIvckUAGB3UdwCAICDggIXAPrYfefDtEMAAADYMxS4ANCn7jsf6sHg0bTDAAAA2DMUuADQpz7/Y9+ZdggAAAB7Ks0uygCAXXL/c4/pgccraYcBAACwp1jBBYA+Q3ELAAAOKgpcAOgzFLcAAOCgosAFgD7CSCAAAHCQUeACQJ9gJBAAADjoKHABoE8wEggAABx0FLgA0AfYmgwAAECBCwD73rkLZ9MOAQAAoCdQ4ALAPnbf+VBveuqNaYcBAADQEyhwAWAf49wtAADALRS4ALBPFZ95KO0QAAAAeko27QAAAFt33/lQD75vPO0wAAAAegoruACwD7E1GQAAYCMKXADYZ5584uG0QwAAAOhJFLgAsM88+/Ro2iEAAAD0JApcANhH3vPWd6YdAgAAQM+iwAWAfeLchbNphwAAANDTKHABYB84d+Gs3vTUG9MOAwAAoKdR4ALAPvCuxmvTDgEAAKDnUeACQI978omHaSwFAADQBQpcAOhxFLcAAADdocAFgB5G12QAAIDuUeACQI+6/7nH0g4BAABgX0m1wDWzC2Z2w8w+2+b2B8xs1sw+3frzk3sdIwCk5YHHK2mHAAAAsK9kU37+D0j6BUm/2uE+/5+7f+vehAMAvYGtyQAAAFuX6gquu39M0lSaMQBAr2FrMgAAwPbshzO458zsWTP7XTN7TdrBAMBuOnfhLFuTAQAAtintLcqb+ZSkM+6+YGYPSvptSa9OuqOZPSLpEUk6nivtXYQAsIPe1Xht2iEAAADsWz29guvuc+6+0Pr7RyTlzOxIm/u+391f5+6vG83k9zROANgpzLwFAADYvp4ucM1s3Mys9ffXK453Mt2oAGB30FgKAADg9qS6RdnMfkPSA5KOmNllSf9EUk6S3P2XJP09Sf+TmYWSKpK+y909pXABYNcUn3lIel/aUQAAAOxvqRa47v7dm9z+C4rHCAFA37rvfKgH3zeedhgAAAD7Xk9vUQaAg+DB4NG0QwAAAOgLFLgAkKLiMw+lHQIAAEDf6PUxQQD2gLurVnWFoatYDJTNWdohHRjvZmsyAADAjqHABQ64sOG69HJNjbrLTHKXRsYyOjaeU6uJOXYJXZMBAAB2FluUgQPu6uWa6jWXuxRFcYE7O93U3Gwz7dD62n3nw7RDAAAA6DsUuMABFjZc1crGyVvu0vQkBdhuorEUAADAzqPABQ6wKGo/VjqK9jCQA+bchbNphwAAANCXKHCBfSBuAhWpUonk3r4o3apc3hS0+S0wVObXw244d+Gs3vTUG9MOAwAAoC/RZArocfVapMsX6wobLplkksZP5VUeztz2Y5uZxk/ldfVSXct1s5mUyUiHjuRu+/Gx0V/cfW/aIQAAAPQtClygh7m7Lr1UU7h8HNYll3Ttcl2FVxWUL9z+KutQOaMz9xQ0PRWq0XANDgYaGcsqk6GD8m5gLBAAAMDuocAFetjSYpR4FtZdmpkOdWw8vyPPUygGGj+5M4+F9hgLBAAAsLs4ZAf0sGboanfkNmzsbSy4PcVnHko7BAAAgL7HCi7Qw0oDydegzKTBLTSBiptUuZpNV6kUKGD78Z5jazIAAMDuYwUX2AXurrDhHcfwdCOXDzQylpGtqkfNpHzeum4yVa9FevGva7r4Yk1XL9X1xb+qanqK5d+9dP9zj6UdAgAAwIHACi6ww6anGpq4Hq5sLR47lNGR4zmZbW/V9Nh4TgMDGU1PhYoi1/BIRqOHsgqCzR/P3XX55boaDW99HH/+5iuhisVApYHb78SMzu5/7jE98Hgl7TAAAAAOBApcYBPurunJUFOToaJmvG346HhOxeLGDRBzs6FuvhKuOTc7PdWUzHT0+PbG7piZyiMZlUe2XoxWK66wuXEV2T2OiwJ391HcAgAA7B22KAObuPFKQxM3QjXDuDBcWox08cWa6rWN7Y0nb4QbmkK5S9OTobxNtyh3l9/mVuZ2oqar3TpvM9yd58QtbE0GAADYW6zgom955JqaCjU73ZRcKo9kdPhIdksNlpqha3a6ubFojaSpiVDjp9aO1gnbFI3uUhRJmczqz7kmrjc0Pd2UR1Iubzp+IqfBoZ1bVS0OBIldmM2koS00qcL2sHoLAACwt3iHi77k7rp8sa7JG6EadVejEW8zvvhire1KapJ63dXu6Gy1snEFt5CwbVmKC9tg3U3XrzU0PRUXt5LUqLuuXKyrkvC429FsuqYmGrJ1z2sWF9MjY1zf2k33nQ/TDgEAAODAocBFX6pWXJWlaM3qpbtUb7gW5rsvIHN5azuHNl/Y+M/n6PHshoLYTDo6vrbJVLPpmptJWBl2afLG7Xc4jiLXyy/UND3ZVNS89flMJo7xzD2FrppUYfseDB5NOwQAAIADhwIXPc3dt7TiuqxaiZT0VR5JlaVmwi3JslnTUDmTWLQeOrpxBbQ0kNEddxVUGgwUZKRC0XTyjrxGRtfeN2y0Xxmu12//bOz8bFNhwzcU0FEkDQ5lKG53WfGZh9IOAQAA4EBijyJ6UqPhun61rsWFeLV1qBzo+Mm8stnuCrNszhSYtL53k1l821aMHspocbEpb9XFQSCdOJ3cRVmKuyzfeVeh42Pmcu1XhovF2y8+Fxej5Mc3qVKJElefsTPOXTirN71vPO0wAAAADiTe5aLnRJHr4gvVleJWkhbmI118ofvzs8VicgFpJo2MdH9dp1GPdPlifc0237grcvIqcBi6Fuaare3R7WMNMqaxQ8krw4ePbm+c0Gq5Dg/R7UUCbM+bnnpj2iEAAAAcWKzgoufMzzXVTKgfw2Z8frY83LnLcLPpeumFWmKBe3Q8q8wWCrzpyXClCdQyd6myFKlWi1RorYS6uyZuhJqeDGUmueJC8o4zeeXyydeRjhzPKZMzTU+EajbjovzoiXzbRlVbMTqW1fTkxjO+mYxpYHB7j+8en2uOImlgINhSN2oAAABgL1DgoufUa8nbaz2S6vVIUucCd2YqXLPiutr0ZKjRse5XSGu15FVYs7jrcaG1E3lhPmrNutVK7Mtdke+6t9jmMUyHDud06PDtr9iul8sHOn0mr2uX6ysXCwpF08nT+TXNrrpVqUS68vKtiwbu0vETOToxr/Oet74z7RAAAAAONN6doucUioEsaG5YObVAKyumnVSW2ndJrtfilcikIm9xoRkXx1E8M3d4JKNiKdDSUqT1HavcpXzh1mMsF7cbnq/uqtfSOfM6MJjRPV9WVKPussCU2+LZ42VR5Lr8Uk3Rupf1+rWGiqVgR1ac+8G5C2elp9KOAgAA4GCjwEXPGSpnlMmECtd1iMplTYNDmxdTuXz7Qs5MicXtxI2GpiZuFamVpUiz06FOns7HRa+vfYyhcqD8qq3H0fpuVqvuG0VxUT15M1wpoEsDgY6N53a9ODSzNYX4dqw+C72auzQ7E+rYeP62Hr9f/MXd96YdAgAAwIGX6tKLmV0wsxtm9tk2t5uZ/byZfdHMPmNmX7PXMWLvBYHpzD0FlYczrYJUGh7J6M67C11trx071P66zfDoxv/lw4avKW6luHirVeMzp2fuKWhwKJBZPEd27HBWJ07fKurC0GUd/iUVCqZXrsQFdLMZP/bSYqSLL9bUqHc/k3evRVE8oimKPHHkkqTEs9IH0X3nQ72bzskAAACpS3sF9wOSfkHSr7a5/bykV7f+fL2kf936L/pcNhvPj12v2XTVapGyWVM+H8jdNTsTamqiqTB0FYuBjh7P6fSZnK5camzY5jw7Haleq+nk6fzKuKClpaZkStyGPD/f1PBoVqfPJI/9aTRcL3+pmljomcXnVMNm3DgraSbt9GSoYyd6awV0abGp61cbqtfjWb1Dw8GG10aKt4wPlTufhz4oHgweTTsEAAAAKOUC190/ZmZ3dbjL2yT9qsfzVj5uZqNmdsLdr+1JgOgZy1t8pyZaXYo93uZbLNmabsGVpUiXXqrpzrsLevVXFLW40NSVi401j1VZinTxpZruvjdeEc5kLKm+lRR3He5k8kYjeRXTpDvvzqtYymhxobkS83qVSndjj9arVSNN3GioVotUGgh05Fh+22ds1zxuLdLll+trmkktzEXK5qSwcet7MJNKpUBDZc7fAgAAoHf0+rvTU5Iurfr4cutzOGDm55qavBlvI47PtMbbfKcmNq6Musdnas1MlcXkLcBh6CvNqDqNzZmfbWp6stF2pm2786mmW8VxPp88k1eS8skLwx0tLoR66Us1LcxHatSluZlIL3yhqhvXamo2t1cwL1u/VVuKX8+wIY2fzKk8nNHgUKDxkzmdPrO9jsz95sknHk47BAAAALT0eoGb9O458R28mT1iZp80s0/ONOu7HBb22vVrjc3vtEqtGhee9Xqb5k+Ki9zNRJF083qoG68kP3/QYYduEMT/++bygQYG4zO8683PRlqY7/4gq7tvWJFeNj0V6aUvVdXs4vtqp15rU7CblM3F28ZPnyloeDRLcau4c/KzT4+mHQYAAABaer3AvSzpjlUfn5Z0NemO7v5+d3+du79uNPP/s3enMbKl52Hf/+97ttqrel/uPjMkbcmmJ5IsiQyDkEFseIYGFDOxZRGIASWBItMOHZBBzIwBB/kiIDItxLGtiEIyCCLEMY2MbQxgCc6HME4QxYgMRRRjRaRmuXt3377dXXvVWd98ONXVXV2nqqv3vvc+P+Bi5nbX8nZX3UY/59muV0+jOJtuJ56413YSZzDheFJgaQzkcoenIE9+LGOgsRdnBo7zi3bm4xeKGss++MT6LTeznNcYePooGMm8dtoRH/9Bjx/8Xo8Pf9Cj1YhGzjkpGwwQRbDz/GQXAw7L5bN/JKRrka77j4vL9x+Hf+SqjyCEEEIIIQ657r+xvg/8hcE05Z8EGtJ/+2oIg4RnmwGP7vtsPZ2ekT8aYCoFi8tpe3m1Zo8EmvufL1WsYcCmlJqaid2/j58x8bhStajNp9OetU5vlyuokSnLkGZzp/XI7mdx67shjx+EBMFBafDTxyE720Hm1zpm0DN7WvMLNvrITwWl0r3Ati0Z26MkeyuEEEIIcb1c6ZAppdT/BHweWFRKPQb+c8ABMMb8CvDrwNvAB0AX+NmrOak4L2GQ0O0kaCvdabtfxntYv5cOgTo6ATlLbV6jlWJvN+3FtW1YWnUoFNOIVVuKu6957GyHtJoJWkNt3qJ2ZJXQwqLF9tbkNLEx4Djj14OUUiyvuswvGvx+guOoiZnOaZlXM9iV+2wzyvz882cxcwsGrRWWNX09z3HB+jSOq7l9z+PZVkivk6CtdO3S/OJVD1y/ft754leu+ghCCCGEEOKIq56i/DPHfN4Af+mSjiMu2PZWyN7OIIBTaR/szTse+cJoQLi1EcwU3KaZWhfLUiyuGEySrq452htq2YrlNZfltcmPNbfgsLMdTyxVLhT11AysbSvs0vTIslSxqO+ND8UCKJYtfN9MDYLDwODlFDduuzz8ODurrVS6p/csvJzm1oS1SCL15lvZFyKEEEIIIcTVuu4lyuIl0WnH7O2kE3qNSTOWSQKPH/ojE4qNMfRnWJ2jFKysO8NJxWmZsTr14COlFCtrTmYJcLGkM3fynlS+oClXrZHnUAoWlmwcR42VBh+1X2qdL1i89skc5YoejmFTKv1TnbOoVGU37UX7/f/0z131EYQQQgghRAapOxSXojEhc8lg3U/xUPZz0s5YpWFuzkJbikrVGg6SOi+VQb/uznZEGCR4Oc3Csk0+fz4Bo1KK1XWHas2i1YhRGipVezjYyXU1jgNhxowoz1MjPbCOo1i/5Q0vCESRIZefnmUW5+Mz736aL3xz9aqPIYQQQgghMkiAKy5FMqX29vCnlFJUahbNenzk42lwu7R6kEmNY0OzEROFCYWiNZiYfLYAr1iyRoLtkwj8hE477Vstla1hdvkwpdTgrNnPceuux/2P/JGp0bYDt+5mZ5CVUuQLEtRepi+897mrPoIQQgghhJhAAlxxKSpVi247GcvMGgOFIz24y6sOYWjodZJhNrdY0iwsO8Pb9LoJjx74MCh53tuJyeU1t+64qIzBVRcpHQ4V0tg7iEq3VMjN2+7EQHYSx9W88akcnXZC4Cfkixb5Cat7hBBCCCGEEKMkwBXnzhhDHKXTfPenJJfKGsdVBP5BhLvfR6uPZDq1Vty64xH4CUFgcD2Fe6gc2RjD00ejU5aNSacv7+1FzC84XKZuJxkvwTbw5GHAG5/KnTjgVkpRKltQll7a60YmJwshhBBCXG8S4IpzVd8N2X4WDYPP6pzF4rLN4wfBSHAL6XClai19CwZBQrMekySGUtkiX9C4nsbNGOYb+CZzTY4x0KzHlx7gTpqMDNDtJqcueRZCCCGEEEKcjAS44ty0mjHPNqORYK+xF+P3E/z+eAS48zxibsGm3YzZfBoO71ffjSmWNes33eye2uvWcjpjf/FpxLGh047BpP3Bln3dvvhXx2e/93X4Ru+qjyGEEEIIIaaQAFecm53tMLPHttfNjvIU0O2MBrf79+m0EtqthHJlPPvpugrLVkTh6OMqBdXa5WdLKzWbTjvI7i8unr5/ttWI2HgSpt8oAxCysuZQnZN/tlfh8xLcCiGEEEJcezK9RpybMDxZutIAvm8yd88aA81GlHk/pRQ3brlozfC+SqXBZG3+8oO/UllTLOmx/barN5xhD/JJRZFh40k43Bm8vz94ayMkCJLjH+CC9HsJjXpEv3d1Z7gKb76V/V4UQgghhBDXi6SCxLnJ5TTdznjgozQjA6H2WTrd7zrJtJU/ubzm9U/maLViotBQKGpy+bOvCToNpRTrt1x63YR2K8Y6hz297WZGkzFpkNtqxCwsnf3aVBCkpeOOo/Byaur3LokNjx74aan5IKPs5dJhYEeHhL2M3tZfveojCCGEEEKIGUiAK87N0orDw4/9sf21y6s2YQB7O4MsmAKt4OYdD8dVQDj2WLOUG2tLDYdUnZVJDK1mTGsQoNbmbXK52YPI4/bbnvg8U5LhSXK2xl5j0uxwuxkP1zAplQas5apFtWaPZZ6fbYX4fZOea/D0ft/wbCtkdT17R68QQgghhBCXTQJccW5yec3tex7bWyH9foLjKBaWnGEfbW3epteJsWxFoZhmW40x1OYtdp8fZCyVgtq8dab+1ZNIEsOj+/5BAEc6jfkq+12LJc321vjHlYJS5Wxn2tuJaDfjYdkzHPRK93sR9d2ItRvpgC/XSzO7zfr4pOj9qdWr62c6zrX37W99Gd6/6lMIIYQQQohZSIArxkSRoddN0JphIDqrXF5z627Gbh/AcRTOoYyrMYZH94Oxfs7qnMXy6uVlBRv1aCS4Tc+W9ruWq9ap+2iPY0z6fW420uC+WrPIF9KLAa6nmV+02X1+MJVaKajULPL5swX+09YaGQOBDw8+DlCku4zXb7pTb/+y++77tas+ghBCCCGEmJEEuAJIg9pnmyGtxqFMqgat4dYdD+8E5bqzajcT+r1kLEhq7MUsLBnsS1qJ026OnwHSgLJ3gXtsn22ENA5lRpv1mLl5i6VBcL+47FAsWTTrEQaoVNP9wGc1U4mzSSuR4wgePwjIF1TmNOzLyrJflc+8+2l476pPIYQQQgghZiUBriBJDA8+6hMdaYU1CcQJPHrg8/onc+c+wKnVnJBJVOn6oEr1ct6eekKMZmCm7G2vG7O3ExNFhmIpneRsHTN4KZ1GHI9ljfd2Y6pzCa6XHipf0OQL55vNLpUsGvXsIVaT5PIa34+HE52VSi+ArKw553q2fX4/wfcTXDcdHnZVvvDe567suYUQQgghxMlJgCtoNWPiKVtQTJJmMs9rgNI+a8LDKWYLLM9LbT57j62lIZeffo76XsizjYMy4n4vob4Xc/d1b2qQ225lB/fGpJ+b9y4uqFtcdmi3p7/mR88E8NobOep7aTm3l1PU5mysc86yJ4nhycOAXjcZTmvO5RU3b78a05qFEEIIIcTZvNz1hWImfj+7RPewZMraU2MM3U7M3m5Epx1jZmzMrM7bmTtwUemQpctSLFnML9rDrKTWafB98443fXVOYni2GY1lYePIHEyMnmBS1jg9w8UGcokxmWubmPC0SkOhaGHZ6dCw9VsuC0vOuQe3AM+3QnrdZGT/b7+Xls9ftne++JVLf04hhBBCCHE2ksEVuJ5GqemDhyb1fsZxOoE4CAZNmyodJnX7rndsAJTLaZZXbZ5tRsNAV6njA8uLsLjsUJu36XbSNUGzDNfy+2Y/yTjCGNjZjuh2EhaX7czMd7li8fxZlPk93586fV563YTd5yHhYF9wrxNnXrAoFTUG6HaSkcFWnqcu7YLD0bJtGExrbsSsrJsr2XMshBBCCCFeHBLgCioVi+dbIXFGW6ZSsLQ6uad0ezPE981BlGcg8A1bmyHrN4/vHa3NO5Sr9nBqc75wsqnNx+n1ErrtGG0pyhVr6uAq21Yn6vu1rOlThHvdhMcPAm7cdscGVTmuZmXdYetpeJA5NbB6wznX4VrNRsTmk3B4Tr8/ufe210t4/VNpGXJjLwaTTm2uzduXFlhel2nNMlxKCCGEEOLFJAGuQFuK2695bD0N6XbS1J5lQaGkmVtwpq6laTbi8RQmDPaszpZxsyxFqXy+WUtjDBtPwuG+V6XSYDwr2Dwt19O4nsLvT46+jEmnJd/7xPhzVms2pbJFp50GncWSdexwqpMwxvBsIzxRcKiUYm7eYW7+YoZHHadQ1HTa4+nl877wcZz/594bl/ZcQgghhBDi/EiAKwBw3XR/7X7/7FmDiavej9puJcPg9vB5nj4KeONTuXPrc7152+Pxg7REe9LXHASTvxmWdbKs8UmEoZnaO32YUukaoqu2vOrw4GN/dFqzurhpzVnefCvi7W+uXtrzCSGEEEKI8yNDpsQIpdSJgttJvZmF0uVm3I5q1LP7WwG63RmjvhnYjuLuGznuvOZNHBw1aVr0RbOOCeKVPviv4yoWlq8ma3uY62nuvZFjYcmmVNbML9rceyN3IXuYJ8n/2R+5tOcSQgghhBDnSzK44kyW1xx6PZ8kPsi4aQ2rM2Tc0unLCXu7EUE/XQtTKKQTjd0LXJNzEbycZmHJHhscZdnw6X9N88kfjXhbf3Xsfr/0n2zyh37xHwDwO79xvv8cLTsdltXpJCNl5ErByrqDIs3yejlN8RwvSCSJ4flWSKOeDrMqFDUra87Mr6k9mNZ8VWT3rRBCCCHEi0sCXHEmjqN57Y0czUaM309wc4pq1T52Z6kxhs2nIa3G6NTcRhDTbMTcvueRm9L7e5xqzaabsdsWJk+EPqu5BZskgUY7IUYRRJrf/ok/zrs/9pNk70OCr31zFQaB7x/7Vp2/9dk1fvOP/s1zO9PaTZenj9K9skqlFyHmF20qVevCMuyPH/j0ugff+G4n4cFHPvc+kTvXAVpCCCGEEEIcJQGuODNtKWrzJ3sr9XtmLLjdlw5mCrj9Wu7UZyqVNaWKNTJkCmD9lou+oD2zSil+6Wf/CjqOyXW79AsFkhPUJ3/3/Rqff78HX/wKv/BPfvlczmRZilt3PcIgIYoMrqfPdZDVUa1WNBLc7ksSqO9GLF6DMuhpvv2tL8P7V30KIYQQQghxWhLgiivRbk3ukQXo9c42pUopxfpN92BNkFaUq9PXBJ3Gm29FFH7xr/L5b/SGH0ssi265fKbHfeeLXwE4t0DXcTXO8VubTsT3Exp7EXEEpbJFqaLZeRZNvH2vGwPXO8D97vu1qz6CEEIIIYQ4gxer0VG8NI7Lop7XYKZ8XrOw5DC3YJ97cPvtb32Zt/VXR4Lb87Yf6F43jXrEgw999nbSkvKNJwGP7vuEUyZGX/e+6jffmhycCyGEEEKIF8P1/o1TvLTSHtDJnz9pyfNlKf7rc/x3f+Kn+dt/+Ms8/FUbK4wv/DmvW5CbJIatp6P7dY1Jy84nTZIGmLumr+m+wi/+1as+ghBCCCGEOKMrDXCVUn9KKfV9pdQHSqlvZHz+80qphlLqdwZ//vpVnFNMFsdpL22rERPHs5cVO65mdd3JDHIrNYuFpesXDKm/+/N888mfJPwI3CCmXPdZ+7iBFVxOkPvZ7339wp9nmjg27GyH3P/Qn9g7rS2V+ZqWyvraZ3DPkolXiUFHydUvgBZCCCGEeMVdWRShlLKAvwv8CeAx8FtKqfeNMb935Kb/hzHmT1/6AcWxmvWIzafhMKAxBtZuOJSrs72tKjWbYtmi20lIYoPtgJc7/z7Z8/DO23+Rm//VHtbhdTuATgy151121s/WczuLz3+jxy9950v0v/APL/y5jkpiw4OPfKLQTI3hXFdRqVrsbEfpN8hAqWKxsmbTasa0mzHaguqcTe4Sd9se57TlySpOWNhoU+iEAES2ZmethF+43r3GQgghhBAvq6tMk/048IEx5iMApdTfB34KOBrgimsoDNM1P8aMJq02noTki7MHqZalKFfOqeH2nL351sHuWjuIURmRnQJy3cvr3fzaN1f537739XNdJTSL+l50bHCrVFpaXixZzC3YhIHBthXagscP0lVF+/dv7MUsr9rU5q9HIJj/sz8C7538fsuPWrj9iP13uxMmLD9qsnGvRuRez/e1EEIIIcTL7CpTKDeAR4f+/njwsaM+o5T6rlLqN5RSP3w5RxPHaTUmB3Wt5ulKduPY8Gwz4MPv9/jg+z02nwbEcXLaI55J7jtfGga3ALGlmBSyxxe4difLRQ61mqTdSiYHtyoNbufmLYqlNKjTWuHlNJataDXjkeAWBqugNqMTlbXPyhjD3m7Igw/73P+wz95OiEmmP88X3vvciZ/H8SNcPxr7IaoMlHcv/zUSQgghhBBXG+BmRQVHfwv9beCOMeaPAX8b+McTH0ypn1NK/Qul1L+ox8E5HlM7dk8kAAAgAElEQVQcFkWGvZ2IdmvyDtvjgoksSWIGwUhMFEEcpVm+D37fp9+73CA3950v8bVvro58zFiabtEhOfKuTRQ0F/KXeLrUZQ+empSRVwoWFm3ufSLH0mr2HqJJ+46Vgl7nfF9bYwxPHgVsb0b0+wa/b9jeinj0IMCcc3+sHSSYjG+LApxL6MsWQgghhBDjrjLAfQzcOvT3m8DTwzcwxjSNMe3B//864CilFrMezBjzq8aYHzPG/FjNOueFnwKAbifmox/02d4K6XUnBwuddsKH3+/x4KM+nVZMkhi2t0I+/H6fD7/f49lmMJa5azZiojD78Z489M89OMny5lsR73zxK3ztb6xkDgvaWSvTL6RBbqLT4LaxkKdb8S78bFnOO8iNY0OjHrG3GxEEo4Hn3EL21GvHVSws2TjO5Cz2tJVQ6px/AvV7hm57PFvc7yV0JwTT3/7Wl0/1XEHOQmW8LRMFfenBFUIIIYS4ElfZg/tbwCeUUveAJ8CfB0Z+01RKrQJbxhijlPpx0oB859JPKjDG8PRRMNOQ2P1AIooMjx8GOK4a6d+s78Z02gl3X/dQg6ip056cyYtjCHyDl7u4UuA334r4ovmPmN9oU2r6YMDP2+ysFom89J+JsRTbtypYYYIVJ4SuhTkavBlDoRVgh+nneyWHqfuQzuidL36FX/gnv3zmx+m0Y548PKh82AbmFmyWVtJALV+wWF61ebYZoVQaNLqu4sYdd/gaTlKds2g1x7O4SkGheL4Rbq87ubKg24mHJdTnIXYsumWPQstHD57TAEYr2rXcuT2PEEIIIYSY3ZUFuMaYSCn1l4F/CljAu8aYf6mU+vnB538F+HeAv6iUioAe8OfNZaTyxBi/b5hUeawtKJctfD+h3xu/URiMfsyYdEhVu5UMB0w5xyS8LvJF38+Ertxv4PrRMCvn9SJWHzR5+lqNxD4IxGJHk1iKYtMn3w6IbE27liOxNav3G+g4QRkwCiJHs3WnSmJdXLHEWYPcJEnLeo/+y9rbiSiWNIVi+hrV5h0qNZt+L8Gy0h5bSC9+JAloTWawWyhazC/Z7G4P+rZVWsZ74453bHB8UpatUBrMkeslSoFtj78Gn3n307zzXu3Uz7ezViTIWZT3+ujE0Cs61JcKI+8XIYQQQghxea502eig7PjXj3zsVw79/98B/s5ln+tllMSG589Cmo0YA5QrFkvLDtasK3kGK1+yuK5i9YbLB78/+2Adk8DeTkh9N8K2FaWKxd5Odt+itsDzLiYLuh/cuv3BwKAja4CUMZTqfZqLhYOPJ4bVBw3sIEab9NtSaviEroUVJcPmcmXACRLmnnXZWStdyPn3ffYMk5U77STz5TUGmvV4GOBCWm58+O/tVszWRkgUGpRKs7VLK85YWfLikkOtZtPtxGhLUSjqqaXLh4VBwt5ORK+XZvHnF+yJO3VzeZ1dZaCgUr2AqcZK0ZrP05of78P2uiHV5z0cP8L3LJqLBYJjSpfV4OJIYqkLzfwLIYQQQrysrjTAFZfDGMPD+z6Bf1Am3NiL6XYS7r3uoWYINDxPYVkQHRmerBTU5tK3ke2oE03FTft409u3mjG1OU19bzT1phTcuJVdBmuModdNSBLIFzTWCacZH+5htf04M4jXJg1+Dyvt9YfBLewHwuD68djkNAUUmv6FBbgqTijV+/y5Lzf4kcUf5Y80/oD5sHmyB5nykk2rl+h1k5GydWPS91USw9rN8T5421FUaif7keP3Ex5+7JMM3hb9Xhp037rrkS/ozNse/XosC27cdjMv5pxmevIs8u2AxSet4XvE6kYUHjbpFR2e3yiPlbbrOGHhaZt8JwQ12Ke7WsIvSi+vEEIIIcRJSB3dK6DbSQiC8R2mUWRotWab9qqU4sZtLy1D1fsfg2JJU6mlmbGFJefUSSdjoNFIeP1TLitrDrU5zfKqw+ufzJEvjGfe+v2ED3/Q58nDgI3HAR9+v099d8KUqgxHBzSFnpUZ6Bkg3wlHgtzioZ7Lq6SjhPWPG9Se98h3I36v+gb/6Oaf4EFh7USPUyhlZz2VgvKUrOfOdjh2P2PSixVxdD7foGeb4TC4PfwcWxvjk9K3NsZvC+kgrKz30IUxhrnNzng1AOl7afFpa+wuy4+a5Dvh8GKJEyYsP25iyzRmIYQQQogTkQD3FeD3k7GeREjLhE+ygieX17z+qRwraw5LKza37nncuH3QR1muWCyt2INezJOfUwFhALV5m5V1j7kFOzPrZozh8X2fOIIkSf/s71Wd5evJmj4c5mz8vM3ReyvSLO7S4+YwnTmtn3aszBfoli9mqndlp4cVJSOZ5Ejb/LOlHyeZuLV3nGUpVtZGL04oBaWKRbE0+WsNguwgVikIzynA7XWzX0+/b8Yma0+6bVZfOKTroC6CMmBH2WdRQK4TYoUHn3f6EU5W9l/26QohhBBCnJiUKL8CHFdPHLwzqZdxEq0V1SllpnMLDrU5exjg3P/An2nyMqTx4yx9md1OMnFSbn0vYjU/OaCctlpn+2aF9Q/30Bll1jo2OH5MmLNp1XJ43XAkQ2cYXey8/6nI0ewtF6d/QadUaAeZYWySd2k6RWphe+r949gQBgbHVVTnbPJFTbOernUqlS3yBT11CFQurwkzMozGgDtlbdBJaJ1O0T4q61hZ7/H9j2c5uuv4vBiV/slaIZQeSGFFMbGTHswOB/t0j06Z5ph9usZIn64QQgghxBES4L4CSmWd9s8e+eVfa6hUzr90U2mF66a/eNfmLeq7o6tbtGZiKak7YZhUGCbEMXiuyrzvvmmlscftjTVaEbkWdi8a/+ShgKVXcmjO56nu9tJAJiuoAhLg2c3yhU3UTSZcDOhHms9885P8f3/ltzM/b4xh62k6cGx/5U91zmJ51WFxefaez8Ulm3YrHgkqlUrXC+kT9kNPUp2z2duJRt4/+8Osjgbf1ZpFYy8eu22tdonlyYMnbc3lqOz2s/PoxhC6B2c60T5dYyjv9anu9NCxIXTTCyj90vFVAjpK+7W9XkToWbTmcsTOJX9vhBBCCCEumJQovwKUUty+lxvZOZrPK27f884tEJlkacVhZd3ByykcRzE3b3HvEzkWlmyUYtjT67iKm7fHh0lFkeHBR30+/gOfRx/7fPD9PlGYncFViuHaoaOOC273dSouSca3xChFkLOGT9RYKvD49Tl2VkuEjs4MZIxWWCcYunVSrfn82FkN4Ods/sz/8pMT7zecpm0OyrsbezG7zzMC+ylcT3P7nkehpNEaHEextGqzuHx+180Wl21KFevgvTLo+97fz3vY0opDoahHblsoahYzbntR5cn76ksFOhWXgzFqqURBay6HsQ6vnbLoVLyR13K4T3dudJ9udadHbbuLFRsU4AYJS09aeN1D/efGoGIzMiHMDmLWP6pT3elR6IRUdvusf1THzbqYI4QQQgjxApMM7ivCcRS37nokg2W2s65oOSul0pLmo2XNi8sOc/M2vcFO1VxeZZbDPn7g4/fTM+//vr69FaXZuvpBtk4p8HIqM8B9863Zf4lv13IUWgFeLxrusgXYXi+PlYMmtqZb8XD7EU5Gtk4lBrcXUt7rEznprtzIPb+MWafi4vY9ynV/WOIauRbbN8oAfPtbX+an/8O/N3IfY8xYRj39eLr3dmHpZFN7cznNzdsuft8Qx4ZcfnpZ80kppVi/6RKGhsBPcF2F42Zfl9NacfOOR+CnQ9VcV524BP/cKMXOepnmXERtu4vXj0hsRWM+T6fqjd18d7VI6KX7dFVi6JVcGouF0X5vY6js9MYGnGkDte0uW3eqFOt95ra76NhggNjWBDkLHSfoxByssCKtSFjYbLNx7/R7gIUQQgghrpupAa5SqgIsGWM+PPLxTxtjfvdCTyYuxGUFtrOwbEWpPDng8/2EwB/PgBoDUQw377jUd9Oe0XLFolK1xlYevflWxNv6q7MfSime3aqQ64TkuiGxpelUvallxq35PKW6PxJAJKQZuNrz3nBXbnmvz/bNMv3iOQ2dUoq9lRLNhQJuLyJ2NIFnDQPx775fg4wgd1KJd1av63HCMOHxg4AwMMNy54Vlm4XF811v4zgKZ8ZyWtfTuOMx5NCbb0W8fUH9t0eFeZvt25Xjbzhln+4+a8LgKkh7dQtNn/mtzsjQMR0l2O1k+Pex+/kxq/frWJHBz9vUlwrnehFGCCGEEOKyTfytXSn154DfB95TSv1LpdQfP/Tp//6iDyauVhAkdNoxYTD7lOXzFkdm4gydKEwoFC3Wb7ncvONRnbPPHtzuU4p+yaW+XKS1kD+2hza2NRv3qnSqLpGtCDyLftFBGTMabBhYeNqevlz2FGJb0yu7BDl7LMv83fdHs3NKTe5z1poTv95PHgTD/cr75c47zyI67YNoOYkN7VZMpx2PTT6+jqwwpvK8y/xGm2KjD8n1OHM85X0YuhbV5+PZXThYUTSJ14+xo4RCK2Dtfl1WEwkhhBDihTbtN/d3gB81xrwJ/Czwa0qp/ca165MGFOcqSQyPH/jc/8Dn6aOAjwf/vYrAxMtN3s9aLE3PMp06uD2l2LHYWSvz5I15Nu7VcII4M9jQicEOL/eiwdH+46MrgfYlCTz4yCeesW/YH5QCH7Vf7gzQrEd88P0+G48DnjwK+OD3+3Q7VxtATXtfeN0w7VV93qPc8Jnf7LB+v46Kr+5Cz5BSNBbG+64Tlfb82uH072vWCqvDD6VIB6ZVn3fP4bBCCCGEEFdjWoBrGWM2AIwx/zfwBeCvKaW+yvjvSuIl8WwzHK7h2c/ItVsxz59d/jAay1LMD4ZRDSmwLJibn94+fpnBbRYzpRTczHp5yBhynYB8KzhzgHU4yC0ULVbWsr9/SZIGpbOI48kZ9jgyBEHC5tPw4L002Fn85GEw7AW/bJ/93tcnf9IYFp+20ebgB6M2YIUJ1Z3rsY+2uZBnb6lAbCkMELgW2zfL+AWH0Du+tDgBEs3Yvud9Csh1ZfCUEEIIIV5c06KEllLq9f3+W2PMhlLq88A/Bn74Mg4nLpcxhmY9ewBRfS/KnFx70RaXHHKeZncnIo4NxZJmftHBsidHiZ/93tfhG1cbkLRqOeaedcZ25YaeNdNqFrcXsvyohdq/lmRgd6VIp5abfscp3nwr4nd+wx48nBr2zB5mDMOhXsfJTcmwlypW5ntpX7sVU6le/oy7v/KbG0D2UCU7TNAZFxK0SfunjUqnGk8rFb5wStGez9PO6NXdWyqy/LiZWTlggMjVPLtRxgliYq1ZfdzMvFQZOTJcXwghhBAvrmm/yfxFQCulfmj/A8aYFvCngP/gog8mLk+vm7DxOODxA39iQDJt9+xFK1Usbt/zuPdGjuVVF/uY4PbzVxzcArRr3nD1S6IViU4Dh/0Jx9OoxLDyqIWVGHRC+sfA/FYH2z99du1t/dXhROn9PcVjz63Azc2WYtZasbw6mmFXCmxbUZu3J5Y6GwPJFVUpH+1JPmxa1l0bqOz2WP+ojnOG1+Ai+UWHZzcr+DkrHXJGWr6cKAhdzdbNCpFn0yt7BEWHTnl8JVaioLEwedCVEEIIIcR1NzGFYoz5LoBS6v9VSv0a8ItAbvDfHwN+7VJOKM6dMQa/b4giQ78fs7s9OdO2r1B4MbI61yG4BUApdtdKNBfyuP2I2Nb4+fEhUFlynYCs1JoyUGr41M+wZ/Y/+7f+Aj/9G3+PfEHjemosW6s0YyudpqnNO3g5zd5OTBQZimVNbc7GstIJ2Y297PdWoZS+n+LY8GwzpNWIMUCppKnN24SBSadsl/TY8LDTOi6zH9ua0LNw+3HmkAFt0n8785sdtu5Uz+VM580vOmwW0yBexQavHxFbKi1fPvLe210tAW2KrSDdu6sUe8sF+qVzmvIthBBCCHEFZvlN9ieA/xL4TaAM/I/Av3qRhxIXJ4rSIVKBb0ClfZHH0RqWVy+/PPmkjg5Tug4i1zrx2hWdmMzSUQXoGQdATfLd92v8re99nd/8o3+TW3c9nm2EtJppEFooalbWHSxrckCZJIad7XAYuJbKFkurDuu3xr/GQlFTKOphTzekMVZt3sJ1NcYYHn3s4x9aBdVuJbRbQXpbDVrB7XveueyzneXix/aNMqsPmugkQSXj0/QU4PWiNA19jvt+L4KxFP3i5H+3Rqe7enfjBCs2aWnyNf+ahBBCCCGOM8tvjSHQA/KkGdyPjZklLBLX0cbjAL+frnWZ9iraNuQLmrkFi7tveHi5653BvY7B7Wn1C9lBSaKgV54hu2YMleddbv7BLrd/f4fVj+t43XD46c9/o8dnv/d1wsCgLShVNOu3HG7ecXHdya+zMYbHDwL2dmLieDCQqhHz4MN+5tAopRQ3brus3nAolTXlisWN2y7Lq+nX0O0kBOHkgN0k6W7eJ4+C47/mY+S+86Xjb0Q6DfvJ6zW218sTh4EZxUsVCBpLpxdhXqKvSQghhBCvrlmilt8iDXD/OPA54GeUUv/zhZ5KXIgoMvS6s12byBU0t+95LK+6ONd86MzLFNxCWorcKzok6iCRmyjwCw69KRm5fbVnHao7PazYpBlHP2b5UROnf9A7+vP/5v/Jw4996rsxrUbCxpOQJ8esg+r3Df1eMlZyHMfTJy/ncprFZYe1m87IeqfAz85UHxUG6UTm08p950t87Zurs99hsAe5Xctl9qh2qt6pzyKEEEIIIS7WLCXK/74x5l8M/n8T+Cml1L97gWcSF2TW1SxKHb+G51WhEgPGYKxLCPIHa2ry7SCthTXpShc/79CpenTL7rFZNhUnlOv+2CRdZdL9ps9vVsh1uvzoP/vfRwJVk0C3ndBpJ5TK2SXVfi87yDQG+r3x91bgJzx5GBCGaTm8ApZWHUplC9tWuJ4afp3HOUvNyImC20PqSwUcP8brhcNz+nmbveXi6Q8jhBBCCCEu1LFRzKHg9vDHZMDUC8hxFNqCeEKyTes0WFlYsikUZ+sbDUNDv5tgDUqa1SWXOV5U9lbHCQsbbfLttLQ39Cx2VksE+YsL/Cu7PfLtIA1O97cDJYCCbmW2rKEdJmTt/1GA66eji9cePCDROk29HmIMtBrxxADXcbMDUqVIg9WRxzI8/Ng/eIpBsnbraciWCikUNGs3HRxHpZncKbQ1/viz+sy7n4b3TnVXjFY8u13B8SMcPyb0LEJPLvwIIYQQQlxn8tvaK0Qpxeq6y9NHwcjQH23ByrqDQpHP66k7ZvcZk06/bezFw0k8tqW4ddfFmdLHeZ4urDTZGJYfNnH9g2m6rh+z8rDB09dqM+2xzbcDynt9dJzQLbm05vKYKcObAMp7GZlXIN8JUYmZusZmX+To8eW2pMFl4FmD20ye5qynvHSFosa2FWFwJHhW45OXO+2EiQUDJu2/ffoo5PZdj63NkPZg0JXWpPc7NMNp/aZ76gsnX3jvc6e632GxrSk0Ayq7PSJb05rP40/okxZCCCGEEFdLAtxXTKlscec1j73diDAwFIrpWpZpk3OztJrxwQqYQSATJoYnDwPuvpE7/4MfcZbM3HHcfoQTZKyKMVCq+zSWClPvX93uUtntDYNVx+9Ravps3K1NDVLVpP5Xk37OZC6vOXJTS9OuepQao8GyUdBYTM/99O7d7OdXUJ2b/CNBKcXtex6bTwI67bRm2Msp1m64YxdFouj4/tp+LyFODOs33ZHe33YzodOJcRxFtWZjO6cLbs/jAoiOEtY+rqMTgzbgEpPvhOyuFOnUTv8+t8KY6vMe+U5AojXN+Vza2yuDnoQQQgghzkQC3FeQl9Osrp9s16VJDO1WQhAkg72nUeZ+0yAwBH5yLmtdJvnMu58+l8zcJGmZL2MBmgacIM66y8FtomQkuIV0fyphQrHepz2fn3jfXtGh2AzGwtjQ1SQn6AHeWykSW5rKXh+dGELPYnelSJhL/7nHjsP/+m//Gf6N9/5RegdjyFsJ81VFLj/9eWxbcfOOl/ZzG9ATLozkZ9ibrFQaCLsuIxnactWiXD3ZaqWjziu7X9ntoWMznManSPuZ55916FS8dI/RCekoYe1+Ax3vX7KImd/q4Pgx9ZXJ/b35lk9lN60K6JVcmvN5Evt6D4ATQgghhLhsEuCKY4Wh4eFHfZIkXQ2jNJOzcyq9zUW6yOAWBqW8GV9fotIhQwAYQ6GVliGrxNCtpGXIXj/K7IHVBgrtYGqAW18qDMuR9SABahTsrhQpNH10bOgXneP36ipFc6lAc6kwcV/r1q2b/IO/9PPc+Pg+VhixcfcO/zD/3/I7v3Hcd2fw9UwJ7AI/YW8nIqPNd4Qx4F3AhZDzLF3Pt8OJo+adIB5eNDiJ/ffM4e+gNlCp92kuZAet1eddKjsHF07s3T7Fps/GvdqJLn4IIYQQQrzsJMAVx9p8EhAdGkw1baKtIi1bvSi573wJvnlhDw9A5Nn0iw65TjgMKAyQaEV7sCJmfqtD8VAZsPO8R7EZsLNSmNgDG9vTA9PYsXj6Wo1ivU+uFxG6Fn7eZvlJe+Qx21WPvZXibOWsU24TOw4PP/mJ4d/f5qv8Ar98/GNO0evGPLofZGb3jx5rfvHkpfHHOe++7NhWkLWG10ByyrMffl8dliiF60f07dHqCh0nI8EtDPa7xYbSXp/m4vSSeSGEEEKIV4lc+hdTJYmh25kc0R6On5SC1RunHwh0nBPvMz2D7RtlGgt5IlsRa0Wn4rJ5t4axNHYQjwS3kGbg7CDGCRJiW48lgI2C1vzxPZuJpWktFNi+WaG+VGBhszPs/9z/U2r4w+nO5y33nS+d6f6bT8PM4DZfUFTnLBxHkcsr1m66LC5nD2oyxuD3E3q9ZOpe3qMuYuhYaz4/tgvXAEHOnmnY2FEqNjhBlFkAoYwhyrgI4vYPBrkdpg0X9j4QQgghhHhRSQZXnJrWsLhi02knOI6iNm9fSMkpDPpuLym4BdIy38VCZnbM62XvWdIGct2QrdsVlh+1sMODwGR3pUhwwnJWrxdlDp7SBkr1Pr3yyfqoZ/G1b67yS9/5Ev0v/MMT3zdJzMSVP/2e4fa9488b+AmPHwZEh3bnrt5wKVcmB5MX2ZPdK7nUF/PUnveGpeehZ7F9o3yqx6vs9lDJeLyaTrm2ibzxrzO2VWbJvAFiR65RCiGEEEIcJgGumEprRaGg6XbHs7jlisXcvMPc/MWf46L7bk8itrP3waZlyJrYsdh4rYbtR+jEEHj2qYYRTZtCPHHi8jn42jdX+YVT3E+pzPZjIF1FdRxjDI/u+wfl8IM+5I3HAd7rXubgsne++JULm6a9r7VQoF3L4foxsa2P74GeotjyJ5bN7C5nlxqHnk3oWiNrqyCtCmjOUBUghBBCCPEqudLL/0qpP6WU+r5S6gOl1DcyPq+UUv/14PO/q5T6kas456tu5YaDZQ2GS5H+13EVSyuXswv0wvbdnlK/4JBolVmG3D60OibybIK8kxnc2kHM4uMmN3+wy/qHe5R2e2ORoZ+3Jw676lQvNrA5zfdcKUWlao21/SoFc1PWD+3rdpLMAWXGQH1vNGv+2e99/VLfF8bS+IUZBnwd9zgTyveNgmRKNvbZrQp+3iZRkGiItWJntZi+v4QQQgghxNCVBbhKKQv4u8BbwA8BP6OU+qEjN3sL+MTgz88B/82lHlIA4Lqa1z6ZY2XNYX7RYu2Gy703vLHdpxfhrD2hF0Iptm5X0/U9Kg04Y614fqM8UwBkhTGr9xsU2iFWYnDChLntLnPPOiO3c4K0xPnQqmEM4OcsOpXzL08+6jQB5OKKPRbgGgPKOj7jHEeTbxMNWk3ffCvis9/7Op//Ru/EZ7sOWjUvs6c3dK2pPb2Jrdm6U+XpazU2b1d5/Ik5uhd8kUMIIYQQ4kV0lSXKPw58YIz5CEAp9feBnwJ+79Btfgr4H0w6aeafK6VqSqk1Y8zG5R/31aa1olq7/LfLZQ2VOqnItdi4V8MOErQx6WqhGYdrVXbT/bRH18SU6z6NhUK6JsYYlh+3xvo1h1niCxrkddSbb0X8zm/M/rq3mnFmifLzrZhqzUydmpwv6Mz7KgXFsubb3/oy77xfgxc0uIX0tfN6EYXWYDSzSqdzP5+xpzd2LGJJ2gohhBBCTHSVAe4N4NGhvz8GfmKG29wAJMA9pTg27D6PaLditIa5BZtyxbqwycdncd1Kk8colTkU6DheL8waiotRadbWtzWOH6PjZOx2+1OULyt796eTv8zXnb9HJWxjcfyC43YzmRik9nsJxdLk75fjaqpzFo29gyBZKaguwt/46a+QvJ/940rFCdWdXho0KmjVcrTmLu8iwIkoxc56mYYf4fUiYlvTLzrX86xCCCGEEC+gqwxwM3/HP8Vt0hsq9XOkZcysOPmznewllSSGBx/5RKEZBhCbT0L6vYTl1YsveT2Jb3/ry/D+VZ/iYoSuhduPx9/cBiI77RpQxmQOsgJQx8eZZ6YSw8LTFoVOyN+/8xZeHPITz7/LD7c+nHq/SRlaQzp1+zjLqw6FgsXebkThTp7f/cIP8WveZ0jsCT+qEsPqgwZ2mAzXNtW2u+S6Ids3K8c/4RWJPJvIO/Q1JYPDn2YYmRBCCCGEGLrKAPcxcOvQ328CT09xGwCMMb8K/CrAH8rXLm7E7AussReNBLcwGOCzGzO/YLCd6/HL9Wfe/TTvvFe76mNcmOZ8nkIrQB16HRIFfsEhHvTwBjkbkxHhJopL6b9deNoi3wlRgzg71A7/fPFNynGH293NiferzVu0W+NlypaGXP74CFcpRblq8Sff+1dmmpxdbAUjwS0M1jV1Qpx+RHjC1UyXzQ5iFjbaw9VT/YLDzlrxVDt2hRBCCCHE1U5R/i3gE0qpe0opF/jzjOfs3gf+wmCa8k8CDem/Pb1Oe3L5aK93CWnBGVzkTtMzMYZcO6C828PrhNm7cGYU5my2b5YJHY1RaWlyt+yO7lZViufrpXSI1eBDiUp3pR6e1Iwx5DoB+ZaPjs/nNdg8mNMAACAASURBVNRRQqETjgSNAJG2+Z3aH55630LRYmEpHTSldPrHtuHmXW+mMvjPvPtp3vniV2Z+D3jd8XMOP9fP3ld81VRiKDZ8qtsd1u7X033HpBcSct2Q1QfNM72/hBBCCCFeZVeW3jDGREqpvwz8U8AC3jXG/Eul1M8PPv8rwK8DbwMfAF3gZ6/qvC+DSRlaQxqEXAfXMbjVUcLqwwZWlAwTqqFrsXW7grFOd42oX3R5+pqDTgxGKUxGaWq/5PL0tRqlho8VJfSKDr2SO+zXdHsRy4+bqEF5qzKwt5SntZC9T3VWOk4wZPcHRGu1CTUUBxaWHGpzNt1ugmWlw6NmCW5Ps9M2ctJJ1llB7n6593Vi+zGrDxuoxAwz+Ie/MwrQSUK+HdIrX6+2ASGEEEKIF8GVhjXGmF8nDWIPf+xXDv2/Af7SZZ/rZTU3b9Osj5eP2raaqXz0ol3Xvtv5zTZ2MDrwyQliattd9lZLp39gpUimTBWGdGpuY3E0YFWxobzbpbbTHwtC57Z7OEHC7trpzxU5Vmb/rwE+MmU+8+6n+b/+vd+d+hiWrShXZiuzzX3nS3ztb6yg4iQN9E8wcKldy1HdGZ2qbIDEGgxvumYWn7bQscm8eLBPJWnpshBCCCGEOLmrj2rEpfFymrWbLnpQOqoUeDnFrTvumacoG2PY2wn58Ad9fvB7PR5+7NM/Qdnzt7/1Zb77/jXsuzWGQnt86rE2UGoGl34cNRiqVM0IbiGNS0sNn3zLP/2TaMXeUmFkX6shXWfTWMjzhfc+x2fe/fTpH3/gzbcict/5En/tr89x48M6t/5gj1s/2KW21Zm5RDexNVu3K4SDTK5REOQsNm9XrnwysdcJWXrUZPV+ncrzLpYf4QYZw8WOMBrCnPTgCiGEEEKcxjUpTBWXpVyxKJVz+L5Ba3Dd87nG8XwrZG/3IDvc6yY8/NjnzmseXu7457iWwe1xrqBPstjoY4fx1CtTinTXbq/snfp52nN5IseiutPDihL6BYfGYn44/OgL732O77zLsZncSd58K+Jt/VW8/yJkeaM5LDFWBsr1PtoYdmfMjgd5h6ev1bCiBKNUukf4ipV2e8xtd4dDuhy/R7nuT5gBfyABQseiXxjPPusowQ5jIse6Fl+jEEIIIcR1JAHuK0gpRS53ftmtJDYjwe0+Y2BnO2L91vRewmu971Yp+gWbXDcaybwZoFu6/B7JXMbwpyw6nn4jFSfUtrsUB1nobtmlvlwgOdRT3C+59Kd8jacNcg+/3rWd7tjXow0UGz57S0XMMSXcQ0pdm8nDKjbMbXfHJjsTJ8SWwppSoqxIp2yPZJ+NYWGjQ7HlY5RCGUO74rG7WrzyLLUQQgghxHUjaQBxZmFoJv6e3e9PL1O+1sHtwO5qicRSw5LdREFsK+orxUs/S2xbxyUBSYBuaUr/qTGsPmxSqvtYicFKDKWGz+r9xomz0l9473Mzv4a573xp7LZ2MPn9YZ3TVOjL5vpRZuCpDcS2JtHpeynrO62A6k535GO17S6Flo8yoAfDqYpNn+rzXsYjCCGEEEK82iSDK87MdtTEuMh1J2eYXoTgFiByLZ68Nkex5eP4MYFn0a14mZOPL1przqPU6I/s0N3/X0Ua3Ca2prWQn/gYuU44VuasACtKKLQCupWTlzbvv5a/8E9+eexzn/3e1/n8N3rwzfH7BTkLq51kT2x+wcpwrTBOM/1JknmhwJBOfd66U6XQ9Fnc7GQ+jnMk6C/X/cwsd3mvT2PpbBOzhRBCCCFeNhLgijOzLEW5atFqjJYpK5WujHkZGEuN7p+9IpFn83y9zMJGG4WBQVYw8Cx0bOiVHNq13NT1Ra4fozKSo9qA40fA6Xt3My9afGNyprG+WCDXaYwE7ImCxkIeruACwkk5/Yjq8y65bpSufALQaS/x0VVLRkFrLo/Rik4tx9x2FyujlDw+HNgbM1wDdZSe8HEhhBBCiFeZBLjiXKyuO1gW1Ae9uI6jWFlzyBeyA60XJXt7HfXKLo9Lc7h+TKIVkXuy3tPI0RjNWJCbKIjcy/2REOZstu5UqT3r4PUjYkvTWMjTqZ4+yD53gyBzP2NfbKTlwXZ08A1Uh/97sC45LWtXCoxhb7mAf2h1UX0xz9yz0V7dRKUfP3hgRZCz8Prja4MCmbQshBBCCDFGAlxxLpRSLK+6LK0YjAE9Jfsmwe05UIogd7p/vt2yy9wzjUoOSoP31wB1y5c/OCvI2Ty7Xb30551FrhMwv9nBDpN0BZFn4fanT7GGQbm4huerRRLbIsjZYyXt7VoODNSe99CJIbEU9cU8nSOVArsrRVYeNocTmQ1pNnj3CnrAhRBCCCGuOwlwxblSSk0d7PrZ7319asnqy8gOYkr1PnaY0C86dK6of3dIKTbvVFjY6JDrhgD0CzY7q6XTnytJJwNf6dd1zpx+xNLj1sgKI69//B7bwxLLws9Y+ZM+oKI9n6c9l0tLmvezvUcEeYeNu1WqOz3cQQ94Y6FA5EkGVwghhBDiKAlwxaUZDht6RdhBTHW7Q7GVBpEKyLcDKjs9Nu5Wp/bJXrTYsXh2u5IOQzLM1O+q44RivU+uFxG6Fq25HEYpFjbb5Nvp1xjkLHbWSoTei/+jpbrTG+kNBk4U3JJAea9Hea9Hp5ajV3Sy1/oolQa3U0Sezc56+STPLoQQQgjxSnrxfwsVL4RXLbjNtQOWnrSGZaX7tAGihMpOj8byNSgxVWosalNxWrp8eCeuFcas3W+gEoM2YAgp7/aJbY0dHZQ6u/2YlQdNnr5eG7n/i8gJTpat3TeMiRUUB4F/vhPSqXjsrpVOfR4VJ1R2+xRaAUYrWnM5OhVXduEKIYQQQhwiAa64FK9ScIsxLD5tj6122acNFFvB9QhwD9FhzPLjFq6fDjQKHc3Oepkgb1Pb7qJjMzJMSQEqGl3xowBlDPNP27TncvQnZS2vO2NIlBmbhAwZ05FJy4uVgdBNJ1oX2uHI668Hu2tbcznCU/ROq8Sw9qCBFSbDx3U223g9j93V0wfNQgghhBAvGwlwxYX79re+DO9f9Skuj9uP0xU+U+g4Y0/PFdJRzI0P68PAFcANE1YeNnjy+hz5TjhzNlMbKHRC8t2Q2NZs3qmSvCg7bY2h2Ayo7HRxgvH9vIaDycg6MUS2pr6YJ8zZ6XRqS1Pd7qJMOPbQyqSZ3NMEuMVGfyS4hUHQ3PBpLOSJHenHFUIIIYQACXDFFEGQ0KzHJImhVLbIFzTqhNm4b3/ry3z3/doFnfB6MhqOiW9RCdh+RHRNelUXnrZHgtt9ykCp3seo/fm9s1GD+6owYWGzzfbNyjme9oIYw8rDJm4/mph9V6SB5cNP1Abl3eP/HhJLDTO6Iw+v0knVp5HrhhPP5PUiuhLgCiGEEEIAHLvtQryiGvWI+x/47GxH7O3EPH4QsPEkxJjZg5w334peueAWIHQtYlsfGw7ulwJfB/lulJmhVYDjR7TmvDRzecj+aqGjHz96/3w7TIdZXQEdJVSed5nfaFOs91HJ5HMUm8HU4HbEhOAWoFuZvMO3WzndGqbItrLfTwriFyU7LoQQQghxCeQ3IzEmjg1bT8ORmMQYaDdjOu3ZS2vf1l+9gNO9AJTi2c1ymsljQt5TQeRe/6ybAfy8TXM+T6/kkiiGfwLPYuNeldZcjtg6rij78rm9iBsf7VHd6VFu+MxvdVj7uD6xPDzf8o8Nbg3QLU3vK45tzc5aafja7/+pL+VPPXirPZcbm7RsgNjS+PnrUQUghBBCCHEdSIArxnQ7Sebv78ZAszFb1vGdL37lnE/1Yok8m8dvzLGzWsSo0SA3AULPIjhFL+ZF6ZacsQB1f3hSp5YHpXh+o8zGvRo7ayW2blfZvFsldizqy0Uef2KeTsXNfIx+wT520JQdxDj96PwyvcawuNFCJwyDVm3AChOqz7MHniXW9Ky7AWJbzTTUqVzvD4dR7f+pbfewg9Nl7SPXYvtGmdhSIxcYtm5XXswhXkIIIYQQF+T6/IYtro1pvy7P8rv0qx7cDilFp5YjyNksbLZx+2lw06247K5MnqCso4R8OwBIs6aXUIK6t1LE6zewonRS8n5wu3m7ijnUNxq51sTM895ykVw3QsfpMKREgdHTA0I7iFl63MIO0++N0YrnayX6pdOV8u7TscEOxzO1Gii0fPYyvv/tWo5i0x/vnQUSDa1ansZS/vhg3Y9we9HY1UNloLzbY++UU4/7JZfHb8zhBDGJUsQvQAWAEEIIIcRlkwBXjCmUsjNZSkG1Nv2X6jffii7mUC8YlRhKez2Kzf2dpXk6JQf05N5NgGK9z/xW5+ADWx12V4t0qrnZnztOs5TFlg8o2jWPxnw+fe4JYsfi6WtzFJo+jh8TehbdijcS3B4nsTVPXqtRbKW9rKFn0Zn2GMaw8vAgqE4PYlh60mLjbvVsA7imHNtM+P4HeZu95QJzz7qD+6fDorZulgnzzsxPbYdJ+hofyUYr0t26Z6IU4TUZTCaEEEIIcR3Jb0pijNaKG7dcnjwMRj4+N29RKE4OcN98K3rp+m5VYsi3A3Rs6Bfs2YIuY1h50MAJ4mF5rNtv41U8dtcmZ++sMGZ+qzPWBzq/2aFfcGZbBWMMqw+a2OH+cxsqOz1ynfDYclaj04zzmWhFp+rRqU4etLQv1w3Ricmc3Lz2cYOd9dLUgU3TJJbGz9l4vdHhWYmCdm3yY7bn8nQrHl43ItEKf4by6qNCz8ostTak7yc7iF+I/mshhBBCiBeRBLgiU7Fk8fqncrRbMUkCxZLGdSeXyr6Mwa3bC1l51ALMsIm2U/XS8uIpQU+hFYwEtzDYWdr0aS7kJwY3xWYwcRNPoRXQms8fe+ZCKzgU3B48t9uP8HoRfmH2TOQYYyi0ArxuiBUlgwxtjsg7XbBmRSbz693vWV3YaBPb+tRnfr5eYuVhEys2w4CzX3BoHvN9TCxNr3z6EunYseiWXQqtYPg67Pfjev2YtY/rPF8vn+k5hBBCCCFENglwxUSWpajWZnuLvGzBLcaw/LiFPrJWptjw6RXdqcFJrjNlZ2k3nJy9M+PZTBjsk51x9pLXm7DmZhDkHg0WVZzg9WNiS6WZxwmBu44SVh80Rvta2yGVnT57ywXaMwTfRx03/VcZqO70eJYR4OooobLTI98NiWxNcyE/9rWlZdc1ct0QO0zwczbhMYO9rDAm3wlJtKJXck9Uon3YzlqJwOtRfd5Dm4OK6f39wAsbbR7//+3da2xk93nf8d9z5s6ZIbnkXrW70iqxW1U1ZDlQ3KysFpYjpLoENSzARSIgdVEDeqEGamG9iCqjL1L0RYoIfdUAldAKLVCnkQFVsFK5lqVAgRokbaTWliVVcquqsrXaC3eXlyE593OevjhDLrlz4WVJnuHw+wEWyyFnz3l4Vl74x////zylQzSIAgAA2GEEXNyw/OsPS08nXcXOytXash7bTAOXSvP1gQF3ZQZuV3TZYGZprZzVxNVad5Mjk6qbXO1rZQJFpu6Qa1L7ui3O5StVTV6taaWrVDub0sypcYWZ7hqnLi4r3Yq6txNLOnS5qlo5u7kt1Gu0s/EZ3WKl93gek3p2HU61o864H+/M6Q2Vr7Y0e6zYvcXaTPXi5p7dxOWqxmdr127u0szp8e2tIJtpcXpMY4st5evd59JNrmy9reYWzvYCAABgY4wJwg3Jv/6wvvX08aTL2CW9V9d6Bd+1liZzPWeWRmaqF/sHmlYurcVD+bj78OqfkSpT/bc1X686kZNs/UxalxSlTLXStXvnl5qavBqvLq6M0sk0Qh05V+m+qLvGlpoDu2sXllqbqu96s8eLmj1W7Lkze2UG7/XGr9RWw60U/y0FLk3NVLc9ZihXbWl8tvM81jyTo+cWpWh715Qk7/cvrPdvdgUAAIDtI+Bi20Y53Db6bGWNTBt2NA4z3TNL25lAl26e2HBL6vzRoi7dPKHKobwqU3ldumVCC0fGNl13lAp08eZxtXKp1fm7jUJaF6+79/hsvWvVdKXL77ZmtW43q3VGKc0fLihacw1XHA4XDnd/74WlRp/buTKN7XUpLs3X+2wDd+Wr2wvvUjx6KOrxw44wFcRbwgEAALCj2KKMbRvVcCtJCkxXbirp8KeLUucMpZvUKGS0PL7xltfVmaWNUG6mdjbY9HnLZiGt5gbnUwdp5dO6cOukgnYkWRx6rxeE3TNiJUm28rU14ctM1VJGY0utvjk2Utw5OghdtVJGlelCz/v2U5kuKEwHGp+tKxVGahTSmj8ytm7lOtUKdeTTRaXbfVZUPZ5/e+STinK1tqKUaWG6EHd03uDZm/fJ6B6v2OeqrdUQXC1n4y3jm/j7rJazylVzKi00OjeKV24vny5z/hYAAGAXEHCxLU899FjSJey6Wimr878wqeJCQ6nQVStm4i3Gmw0mZhs2NdpN0aDzvqWsMs1a99lXl5o9RiHNHi8pe32Tqfjtqo1lNH2punqt9GyoYqWp87dOyDcbcjsruX3HFLnr2CcVpZvd54BX6mjm0jp6rrIaVlORa+pSfHZ4o1Xw5fFcPA6qR3bOVtsa74Rbk1RYaqq4kNHlU5sIqWaaO17S4lRBuWpLUTpQbSv/DQEAAGBLEvl/32Y2Jel5SWckfSzp77r7XI/3fSxpUVIoqe3ud+1dlejnIITbFWEmpUqPbbL73eJUXsVKQ2pHCjrTetwUj0Dq0Tk4Sgc6/wuTGltsKltrK4giNXNp1YsZnfh4Yf1YIkkKI5Xn66pMx89u6tIl3f7mWyrPL+ji6dN6/65fUr1Y3HS92XpbqR5NrlZuWx9LK0oFsvr6ldjApfHZmirThYEdkWuljGrFrArLzdWtym7S/OGCJq/UusYu5ast5Zdbqpc218CqnU0x+xYAAGAPJLW89KSkP3H33zOzJzuvf6fPe+919yt7VxoGOUjhdpRFqUAXzkyoPF9XYamlMB2oMpXv39XXPd72G5gWDhdWV2bzy824WdJ1zZ0Cl/JLLVWmpdP/50P9rT9+WUEYKnDX1KUZ/ZWfvKM//vu/pWq5vKl6U53t1td3ozJJtbG0Zm6e0E3/d673NmMzpZvh4NV0M105WVK+2lJhqaUoiM9a5/qcvw08njm82YALAACAvZFUwP2qpC93Pv73kv5U/QMuMPJy1ZbGr9aUbkeqj2VUmSr0HNezkzwVqDI9psr04PelG6GOfVKJz+Z2wuzckXj2bZgKenaVdimu311nX3lV6fa1UTnpMFRQr+vzf/bn+osH/vaGdWZrbeWWW7Iex4Yji7dbS1Irm+o9ysh9c8+yM1Jo7VihbI8RP9K1ztRblW6GKs3XlW5FqhczWh7PbXvWLgAAALolFXCPufsFSXL3C2Z2tM/7XNIPzcwlPePuz+5ZhejC6u3uGFuoa/ri8uoZz0wjVHGhoQu3Tmx5tuyO65x9TbU7wbETZg9drqqVT6tRSKudTSnTCNcFSzdpcaqg0vyC5g7fpEoYaurSp8q0m5KkwF0n/9/HG97+0KUlleYb17YN69oWZFc8V3ipc263Ml1Qvtpa1w056swQ3krDq7VqpWzPlWM3aWkit6Vr5ZeaOvLp4rqzvOXZmi7esoWzygAAABho1wKumb0mqVeb3W9v4TJfcvfznQD8qpl94O5v9Lnfo5IelaRjmcKW68VghNtd4q6pNQ2apM5c18g1caWm2ROlxEqTpFytpSDstSoaj9ZpjJU1c3pch88tKtuIVzvdTLPHxpRutDU1E+rDz/0NmbvcAt32o/+qoxd+JklqFAaPW8rWWirNN7oaP6192U4HqzOHG2MZXTlR0tRMVakwkktanshp9ujmz/pezwPTzKlxHTm3qNXpwh6fVW73aMbV/0KuwxeWus7ypluRynP1kTznDQAAkIRdC7jufl+/r5nZJTM70Vm9PSFpps81znd+nzGzFyV9UVLPgNtZ3X1Wkm4rTPaZI4LteP6ZR6SXkq5iNKVbUc8tviapsLz9+as7wuMuxL3mw5qkVGdcT5gOdOnMhFKtUEHoauVSSrUj3fTRvMylKH3tXO8Hv/Q3NfHajIKopfd+eXDPuLFKs++9V+TqbZXm6lqain+oVRvP6dNyVkHoigLr2TBrqxpjGZ377CHll+PV4fpYessrrplGKIu6v5nApWKlScAFAADYIUnti3tJ0jc6H39D0veuf4OZFc2svPKxpF+T9O6eVQhJ0tnn7tDbL00mXcbIilLWd7ZsmE72bGZhqal0o/dYnnjr7/qGVGEmFTdyMlOx0uza1ivFn5o5eUYffOEL+uiv3z64gE18+4Hr2ozZ1T9n8YiknTzbaqZ6KataObut7cSDztlyBhcAAGDnJHUG9/ckfdfMvinp55K+LklmdpOkf+PuD0o6JulFi+dFpiX9obv/IKF6D6Szz92he1+4J+kyRlqUiuei5pda637aFJlUmUp2q/3YYrPnT8BcUpgKtDTRf4uxufcOxqmUfnTPPZo7Pt7/z4aRigsNpZvhujO3fd+/wdeHwcqYoOvPKkcmLR4avFUbAAAAm5dIwHX3q5J+tcfnz0t6sPPxR5I+v8eloYNwu3eunCjpyKdLytVaqw2NFqYLqo5vrYnRTgtTQc+A6ZLmjo4NXCGtlrIav1rr2mLsZlo81P9MbKoZ6sTPFmSRX5vPq2vNpa6/Y7SNZk9JuXyyrKM/rygVRavfVK2Y0XK5z2gmAAAAbFlSK7gYYoTbveWpQDM3jyvVCpVqR2rl0kOxbXVpMqfyfL07pAamWnnw/NdWPq2lydz6Dsid1cp2rn9n6KlLywrCa6u/Kw2M29mUquWMxmfr8ec9vl6jkN43K6DtbErnf3FSY5WmDl2uKggjFZZbOvXhvK6eKG34TAEAALAxAi66/OjWzyRdwoEUZlLJjwVao51La/Z4UVMXl1eXTt1MM6fH43m4G5g7VlK1nNNYJT4juzyRU7MwYLXSXYXlVnfHZkmZZqiFI5OqTBVUXGwq1Y7UKGRUH0tvqpbdNFZpXJthXEhr/sjYwA7Lk1eq18YuSXGH5fOLunBmcmD4BwAAwMYIuFgn//rD+tbTvaY74SBansirWs4pV23JA1OjsLVA2RjLqDG2+S24burZOXllFJCnrs297X6TK9sIZaGrWdibVfDy1Zomr1wb8zS21FJheaFvWM3V2kr1GbtUnqtr7vj2RxoBAACAgIs1CLfoxYO4g/CuM1O1nNVYZX1zq0jScuc8cqoZanyurmy9rWY+rcpUXmEmpXQz1NFPKkq1o9V9zbPHilruF4Z3QuTrwq3UWeh2aeJqVVdvKnf9kVQ76nmpeOxSuCtlAgAAHCQEXEgi3GI4zB4rKtMI13UbjlKmham8MvW2jv98QdbJsLlaW6WFui6eHteRT5eUXtn22wmcU5eW1cql1Szszj9z6Vb/sJqrtnt+rVFI91yhjkx780MEAACAEUfAhSQRbvcLd5Xn6p3mTa5qOauF6cK2ZrNKUq7a0vjVmjLNUI1CWguHx9TOJncO1FOB5o6O6ei5RcnjsBhErhM/q6idDlbDrdT5PZKmLy4P2PZb09VC90rqTojSA2YYZ3v/fYSZlBY7zbdWVn4jk9qZYHWVGgAAANtHwIWeeuixpEvAJh35dFH55dZqOCrP1VVYaurCmcmBY3t6KVQaOnxhSdYJkulWU2NLTV24ZWJgk6Rd5a7pi8vrtv0GLrm7ss2wZwOqbCOUB1pduV37tSDssVy6iRo2c844SgVaLmfjecFrbhNZPOapn7mjRTUKGZXn6goi13I5q8VDhaHonA0AALDfEXAPOMLt/pGpt9eFWykOf+lWpOJiU8tbmQfrHo/kuf78aCQdulzV5VPjO1X2lgSR99z6uzIuqJde4VaKg2attPkGV4VKQ4cuV5VuRfG26OlCPIJoQNi9erwkt2UVO52iPTDNHh1TvThgu7GZquO5xOccAwAAjCIC7gFGuN1fcvXe5zoDj7cabyXgBqEriLpT4crZ1n7SjVDjs/GW5nohrcWpgqL09rZH9+JmfdOsd36ta0Bl0uJkXmFgmrxaW12NjiyeO7s8sbkmU/mlpg5fWFoN/KnQNXm5Krm0OGA1VoFp9kRJc8eKCsJIYTpIfGwRAADAQUbABfaJdp8guXKGcysGbYcN+5znzS23dPRcZTVEZmttlecbunBmQuEOndv1wFQtZVVYXN9JeSXvrmTflde1Ykbzh8ekwNQqZFSaqykVxmeTlybzm972O3l5fTdkKf7BweTVmhanBq/irtQdBsywBQAASBoB94Bi9Xb/qRczilIma3vXWdS+s2H78MC0PJ5TsdLoOj9amepxLXdNX1xavz1akkfxSufVkzvXyOnq8aKOtiNlOyvWK4F67ffsJl09VlR1zfddL2ZUL25+S/JamX4dkaN4pTtKsSoLAACwH+zc3kLsG4TbfcpMF2+eUDOfklscRluZQJduHt/WNuHZY0XVStn4WoHF4Xa60HOrcxC60j1muJqkQrW1ne+mL08FunTLhC6emdDCVKHn2Vvznb1vq0/X4ygwRTR/AgAA2DdYwT1gCLf7W5hN6eKZSaXakRS5wswNnPkMTFdOlhW0I6XaUTweyF355ZY8MDUK6dVrD9rqu1sBsJVLK53vHv8jdVZ0e5wh3q75I2M6cm6xazV7/nCBM7UAAAD7CCu4B8jd7zyRdAnYIWE6iM+97kD4itKBWvm0xioNnfpwTkfOL+noJxWd+nBOmc424ZWzsdF1t4tMcafhXdLqc7bXNTh0b1W9mNXlk2U1sym54vPOs8eKWpoa0GAKAAAAQ4cV3APi7HN36MtP1pIuA0MqU29fGxvknWXM0HXsk4rOfeaQZBafjf00UrbWlpspcNfyRG5XA26mFcot3pK8lknxKvYOqpeyulAaMN4HAAAAQ4+AewCcfe4O3fvCPUmXgSFWmq93hUhJss6W5XopG5+NvXlC6UaodDtUK5uOt0jvon6d+wDSJgAACqxJREFUo139V3cBAABwcBFwRxzhFpuRiro7M0uSXF3zctu5lNq5vQmXrXxarVxK2XrY1UV58RDbhwEAALAeZ3BHHOEWm9HrfK0UbwWuj21v9M5OmTk9rnoxs9o5up0OdPlUec9CNgAAAPYPVnBH2PPPPCK9lHQV2A+q5azKc2ll620F3mniZNLCdGFbI4h2UpQKNHN6XEEYySJXmL6BztEAAAAYaQTcEfX8M4/o7Zcmky4D+4WZLt08rmKlqbFKQ1HKtDSZVyPh1du1olQgsWgLAACAAQi4I4hwi20x0/JETssTuaQrAQAAALaFM7gjhnALAAAA4KAi4I6Qu995gnALAAAA4MAi4I6QLz9ZS7oEAAAAAEgMAXdEPPXQY0mXAAAAAACJIuCOAMItAAAAABBw9z3CLQAAAADECLj72J0PtJMuAQAAAACGRiIB18y+bmbvmVlkZncNeN/9ZvZTM/vQzJ7cyxqH3Z0PtPVg8HjSZQAAAADA0EhqBfddSQ9LeqPfG8wsJekPJD0g6XZJv2lmt+9NecONcAsAAAAA3dJJ3NTd35ckMxv0ti9K+tDdP+q8948kfVXS/9r1Aocc4RYAAAAAug3zGdyTkj5Z8/pc53MHGk2lAAAAAKC3XQu4Zvaamb3b49dXN3uJHp/zAfd71MzeMrO35sPm9ooecne/80TSJQAAAADA0Nq1Lcruft8NXuKcpNNrXp+SdH7A/Z6V9Kwk3VaY7BuE96u733lCX36ylnQZAAAAADC0hnmL8puSPmtmt5pZVtJvSHop4ZoSQbgFAAAAgI0lNSboa2Z2TtJZSS+b2Sudz99kZt+XJHdvS/ptSa9Iel/Sd939vSTqTRLhFgAAAAA2J6kuyi9KerHH589LenDN6+9L+v4eljZ0CLcAAAAAsDnDvEX5wHv+mUeSLgEAAAAA9g0C7pB6/plH9PZLk0mXAQAAAAD7BgF3CBFuAQAAAGDrCLhDhnALAAAAANtDwB0iZ5+7g3ALAAAAANtEwB0i975wT9IlAAAAAMC+RcAdEk899FjSJQAAAADAvkbAHQKEWwAAAAC4cQTchBFuAQAAAGBnEHATRLgFAAAAgJ1DwE3InQ+0ky4BAAAAAEYKATcBdz7Q1oPB40mXAQAAAAAjhYC7xwi3AAAAALA7CLh7iHALAAAAALuHgLtHCLcAAAAAsLsIuHuEcAsAAAAAu4uAuwfyrz+cdAkAAAAAMPIIuLss//rD+tbTx5MuAwAAAABGXjrpAkbZ3e88oS8/WUu6DAAAAAA4EFjB3SWEWwAAAADYWwTcXUK4BQAAAIC9RcDdBU899FjSJQAAAADAgUPA3WGEWwAAAABIBgF3BxFuAQAAACA5BNwdQrgFAAAAgGQRcHcA4RYAAAAAkkfAvUF3PtBOugQAAAAAgBIKuGb2dTN7z8wiM7trwPs+NrN3zOzHZvbWXta4WQ8GjyddAgAAAABAUjqh+74r6WFJz2zivfe6+5Vdrmdb2JoMAAAAAMMjkYDr7u9LkpklcfsdQbgFAAAAgOEy7GdwXdIPzex/mNmjSRezgnALAAAAAMNn11Zwzew1Scd7fOnb7v69TV7mS+5+3syOSnrVzD5w9zf63O9RSY9K0rFMYVs1bwbhFgAAAACG064FXHe/bweucb7z+4yZvSjpi5J6Blx3f1bSs5J0W2HSb/TevZx97g7phd24MgAAAADgRg3tFmUzK5pZeeVjSb+muDlVIs4+d4fufeGepG4PAAAAANhAUmOCvmZm5ySdlfSymb3S+fxNZvb9ztuOSfozM3tb0l9Ketndf5BEvYRbAAAAABh+SXVRflHSiz0+f17Sg52PP5L0+T0urQvhFgAAAAD2h6HdojwMCLcAAAAAsH8QcPsg3AIAAADA/kLA7eNHt34m6RIAAAAAAFtAwO0h//rD+tbTvUb4AgAAAACGFQH3OoRbAAAAANifCLhrEG4BAAAAYP8i4HYQbgEAAABgfyPginALAAAAAKOAgCsRbgEAAABgBBz4gPvUQ48lXQIAAAAAYAcc6IBLuAUAAACA0XFgAy7hFgAAAABGy4EMuIRbAAAAABg9By7gEm4BAAAAYDQdqIB75wPtpEsAAAAAAOySAxVwHwweT7oEAAAAAMAuMXdPuoYdZ2aXJf3sBi5xWNKVHSpnFPF8NsYzGoznszGe0WB7+Xxucfcje3QvAABwA0Yy4N4oM3vL3e9Kuo5hxfPZGM9oMJ7PxnhGg/F8AABALwdqizIAAAAAYHQRcAEAAAAAI4GA29uzSRcw5Hg+G+MZDcbz2RjPaDCeDwAA6MIZXAAAAADASGAFFwAAAAAwEgi4fZjZ75vZB2b2EzN70cwmk65pmJjZ183sPTOLzIxOph1mdr+Z/dTMPjSzJ5OuZ9iY2XNmNmNm7yZdyzAys9Nm9rqZvd/539c/SrqmYWNmeTP7SzN7u/OMfjfpmgAAwPAg4Pb3qqTPufsdkv63pH+ScD3D5l1JD0t6I+lChoWZpST9gaQHJN0u6TfN7PZkqxo6/07S/UkXMcTakp5w978m6Vck/UP+G+rSkPQVd/+8pDsl3W9mv5JwTQAAYEgQcPtw9x+6e7vz8r9JOpVkPcPG3d93958mXceQ+aKkD939I3dvSvojSV9NuKah4u5vSJpNuo5h5e4X3P1/dj5elPS+pJPJVjVcPLbUeZnp/KKZBAAAkETA3ax/IOm/JF0Eht5JSZ+seX1OhBNsk5mdkfQFSf892UqGj5mlzOzHkmYkveruPCMAACBJSiddQJLM7DVJx3t86dvu/r3Oe76teNvgd/aytmGwmeeDdazH51hZwpaZWUnSC5L+sbtXkq5n2Lh7KOnOTm+EF83sc+7OuW4AAHCwA6673zfo62b2DUm/LulX/QDOU9ro+aDLOUmn17w+Jel8QrVgnzKzjOJw+x13/09J1zPM3H3ezP5U8bluAi4AAGCLcj9mdr+k35H0d9y9mnQ92BfelPRZM7vVzLKSfkPSSwnXhH3EzEzSv5X0vrv/y6TrGUZmdmSlq72ZFSTdJ+mDZKsCAADDgoDb37+SVJb0qpn92Mz+ddIFDRMz+5qZnZN0VtLLZvZK0jUlrdOU7LclvaK4OdB33f29ZKsaLmb2HyX9haS/ambnzOybSdc0ZL4k6bckfaXz786PzezBpIsaMickvW5mP1H8Q6VX3f0/J1wTAAAYEnYAd94CAAAAAEYQK7gAAAAAgJFAwAUAAAAAjAQCLgAAAABgJBBwAQAAAAAjgYALAAAAABgJBFzgADOzH5jZvJkxZgUAAAD7HgEXONh+X/HcVQAAAGDfI+ACB4CZ/bKZ/cTM8mZWNLP3zOxz7v4nkhaTrg8AAADYCemkCwCw+9z9TTN7SdI/l1SQ9B/c/d2EywIAAAB2FAEXODj+maQ3JdUlPZ5wLQAAAMCOY4sycHBMSSpJKkvKJ1wLAAAAsOMIuMDB8aykfyrpO5L+RcK1AAAAADuOLcrAAWBmf09S293/0MxSkv7czL4i6Xcl3SapZGbnJH3T3V9JslYAAABgu8zdk64BAAAAAIAbxhZlAAAAAMBIIOACAAAAAEYCARcAAAAAMBIIuAAAAACAkUDABQAAAACMBAIuAAAAAGAkEHABAAAAACOBgAsAAAAAGAn/HxY1/HYu5w3mAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# This may take about 2 minutes to run\n", + "\n", + "plt.figure(figsize=(16, 32))\n", + "hidden_layer_sizes = [1, 2, 3, 4, 5]\n", + "\n", + "# you can try with different hidden layer sizes\n", + "# but make sure before you submit the assignment it is set as \"hidden_layer_sizes = [1, 2, 3, 4, 5]\"\n", + "# hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]\n", + "\n", + "for i, n_h in enumerate(hidden_layer_sizes):\n", + " plt.subplot(5, 2, i+1)\n", + " plt.title('Hidden Layer of size %d' % n_h)\n", + " parameters = nn_model(X, Y, n_h, num_iterations = 5000)\n", + " plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)\n", + " predictions = predict(parameters, X)\n", + " accuracy = float((np.dot(Y,predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size)*100)\n", + " print (\"Accuracy for {} hidden units: {} %\".format(n_h, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interpretation**:\n", + "- The larger models (with more hidden units) are able to fit the training set better, until eventually the largest models overfit the data. \n", + "- The best hidden layer size seems to be around n_h = 5. Indeed, a value around here seems to fits the data well without also incurring noticeable overfitting.\n", + "- Later, you'll become familiar with regularization, which lets you use very large models (such as n_h = 50) without much overfitting. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: Remember to submit the assignment by clicking the blue \"Submit Assignment\" button at the upper-right. \n", + "\n", + "**Some optional/ungraded questions that you can explore if you wish**: \n", + "- What happens when you change the tanh activation for a sigmoid activation or a ReLU activation?\n", + "- Play with the learning_rate. What happens?\n", + "- What if we change the dataset? (See part 7 below!)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 7- Performance on other datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want, you can rerun the whole notebook (minus the dataset part) for each of the following datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Datasets\n", + "noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()\n", + "\n", + "datasets = {\"noisy_circles\": noisy_circles,\n", + " \"noisy_moons\": noisy_moons,\n", + " \"blobs\": blobs,\n", + " \"gaussian_quantiles\": gaussian_quantiles}\n", + "\n", + "### START CODE HERE ### (choose your dataset)\n", + "dataset = \"noisy_circles\"\n", + "### END CODE HERE ###\n", + "\n", + "X, Y = datasets[dataset]\n", + "X, Y = X.T, Y.reshape(1, Y.shape[0])\n", + "\n", + "# make blobs binary\n", + "if dataset == \"blobs\":\n", + " Y = Y%2\n", + "\n", + "# Visualize the data\n", + "plt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**References**:\n", + "\n", + "- http://scs.ryerson.ca/~aharley/neural-networks/\n", + "- http://cs231n.github.io/neural-networks-case-study/" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Assignments/Python_Basics_with_Numpy.ipynb b/Assignments/Python_Basics_with_Numpy.ipynb new file mode 100644 index 0000000..f3c7f1b --- /dev/null +++ b/Assignments/Python_Basics_with_Numpy.ipynb @@ -0,0 +1,1299 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Python Basics with Numpy (optional assignment)\n", + "\n", + "Welcome to your first assignment. This exercise gives you a brief introduction to Python. Even if you've used Python before, this will help familiarize you with the functions we'll need. \n", + "\n", + "**Instructions:**\n", + "- You will be using Python 3.\n", + "- Avoid using for-loops and while-loops, unless you are explicitly told to do so.\n", + "- After coding your function, run the cell right below it to check if your result is correct.\n", + "\n", + "**After this assignment you will:**\n", + "- Be able to use iPython Notebooks\n", + "- Be able to use numpy functions and numpy matrix/vector operations\n", + "- Understand the concept of \"broadcasting\"\n", + "- Be able to vectorize code\n", + "\n", + "Let's get started!\n", + "\n", + "## Important Note on Submission to the AutoGrader\n", + "\n", + "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n", + "\n", + "1. You have not added any _extra_ `print` statement(s) in the assignment.\n", + "2. You have not added any _extra_ code cell(s) in the assignment.\n", + "3. You have not changed any of the function parameters.\n", + "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n", + "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n", + "\n", + "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/neural-networks-deep-learning/supplement/iLwon/h-ow-to-refresh-your-workspace)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of Contents\n", + "- [About iPython Notebooks](#0)\n", + " - [Exercise 1](#ex-1)\n", + "- [1 - Building basic functions with numpy](#1)\n", + " - [1.1 - sigmoid function, np.exp()](#1-1)\n", + " - [Exercise 2 - basic_sigmoid](#ex-2)\n", + " - [Exercise 3 - sigmoid](#ex-3)\n", + " - [1.2 - Sigmoid Gradient](#1-2)\n", + " - [Exercise 4 - sigmoid_derivative](#ex-4)\n", + " - [1.3 - Reshaping arrays](#1-3)\n", + " - [Exercise 5 - image2vector](#ex-5)\n", + " - [1.4 - Normalizing rows](#1-4)\n", + " - [Exercise 6 - normalize_rows](#ex-6)\n", + " - [Exercise 7 - softmax](#ex-7)\n", + "- [2 - Vectorization](#2)\n", + " - [2.1 Implement the L1 and L2 loss functions](#2-1)\n", + " - [Exercise 8 - L1](#ex-8)\n", + " - [Exercise 9 - L2](#ex-9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## About iPython Notebooks ##\n", + "\n", + "iPython Notebooks are interactive coding environments embedded in a webpage. You will be using iPython notebooks in this class. You only need to write code between the # your code here comment. After writing your code, you can run the cell by either pressing \"SHIFT\"+\"ENTER\" or by clicking on \"Run Cell\" (denoted by a play symbol) in the upper bar of the notebook. \n", + "\n", + "We will often specify \"(≈ X lines of code)\" in the comments to tell you about how much code you need to write. It is just a rough estimate, so don't feel bad if your code is longer or shorter.\n", + "\n", + "\n", + "### Exercise 1\n", + "Set test to `\"Hello World\"` in the cell below to print \"Hello World\" and run the two cells below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "53ecb05267db45908a4d1c3f727eeb1c", + "grade": false, + "grade_id": "cell-edef848c738402d1", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# (≈ 1 line of code)\n", + "# test = \n", + "# YOUR CODE STARTS HERE\n", + "test=\"Hello World\"\n", + "\n", + "# YOUR CODE ENDS HERE" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test: Hello World\n" + ] + } + ], + "source": [ + "print (\"test: \" + test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected output**:\n", + "test: Hello World" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "What you need to remember :\n", + " \n", + "- Run your cells using SHIFT+ENTER (or \"Run cell\")\n", + "- Write code in the designated areas using Python 3 only\n", + "- Do not modify the code outside of the designated areas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1 - Building basic functions with numpy ##\n", + "\n", + "Numpy is the main package for scientific computing in Python. It is maintained by a large community (www.numpy.org). In this exercise you will learn several key numpy functions such as `np.exp`, `np.log`, and `np.reshape`. You will need to know how to use these functions for future assignments.\n", + "\n", + "\n", + "### 1.1 - sigmoid function, np.exp() ###\n", + "\n", + "Before using `np.exp()`, you will use `math.exp()` to implement the sigmoid function. You will then see why `np.exp()` is preferable to `math.exp()`.\n", + "\n", + "\n", + "### Exercise 2 - basic_sigmoid\n", + "Build a function that returns the sigmoid of a real number x. Use `math.exp(x)` for the exponential function.\n", + "\n", + "**Reminder**:\n", + "$sigmoid(x) = \\frac{1}{1+e^{-x}}$ is sometimes also known as the logistic function. It is a non-linear function used not only in Machine Learning (Logistic Regression), but also in Deep Learning.\n", + "\n", + "\n", + "\n", + "To refer to a function belonging to a specific package you could call it using `package_name.function()`. Run the code below to see an example with `math.exp()`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "7cec1a2c77dcc9c6a59470e3daf70f45", + "grade": false, + "grade_id": "cell-7f38ddeceef22374", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "import math\n", + "from public_tests import *\n", + "\n", + "# GRADED FUNCTION: basic_sigmoid\n", + "\n", + "def basic_sigmoid(x):\n", + " \"\"\"\n", + " Compute sigmoid of x.\n", + "\n", + " Arguments:\n", + " x -- A scalar\n", + "\n", + " Return:\n", + " s -- sigmoid(x)\n", + " \"\"\"\n", + " # (≈ 1 line of code)\n", + " # s = \n", + " # YOUR CODE STARTS HERE\n", + " s=1/(1+math.exp(-x))\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return s" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "150772e06208b50e91305b4ecf1421d4", + "grade": true, + "grade_id": "cell-6a7680d0a31b818e", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "basic_sigmoid(1) = 0.7310585786300049\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "print(\"basic_sigmoid(1) = \" + str(basic_sigmoid(1)))\n", + "\n", + "basic_sigmoid_test(basic_sigmoid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Actually, we rarely use the \"math\" library in deep learning because the inputs of the functions are real numbers. In deep learning we mostly use matrices and vectors. This is why numpy is more useful. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "bad operand type for unary -: 'list'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# x becomes a python list object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mbasic_sigmoid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# you will see this give an error when you run it, because x is a vector.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mbasic_sigmoid\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;31m# s =\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# YOUR CODE STARTS HERE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mx\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 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;31m# YOUR CODE ENDS HERE\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: bad operand type for unary -: 'list'" + ] + } + ], + "source": [ + "### One reason why we use \"numpy\" instead of \"math\" in Deep Learning ###\n", + "\n", + "x = [1, 2, 3] # x becomes a python list object\n", + "basic_sigmoid(x) # you will see this give an error when you run it, because x is a vector." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, if $ x = (x_1, x_2, ..., x_n)$ is a row vector then `np.exp(x)` will apply the exponential function to every element of x. The output will thus be: `np.exp(x) = (e^{x_1}, e^{x_2}, ..., e^{x_n})`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# example of np.exp\n", + "t_x = np.array([1, 2, 3])\n", + "print(np.exp(t_x)) # result is (exp(1), exp(2), exp(3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Furthermore, if x is a vector, then a Python operation such as $s = x + 3$ or $s = \\frac{1}{x}$ will output s as a vector of the same size as x." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4 5 6]\n" + ] + } + ], + "source": [ + "# example of vector operation\n", + "t_x = np.array([1, 2, 3])\n", + "print (t_x + 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any time you need more info on a numpy function, we encourage you to look at [the official documentation](https://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.exp.html). \n", + "\n", + "You can also create a new cell in the notebook and write `np.exp?` (for example) to get quick access to the documentation.\n", + "\n", + "\n", + "### Exercise 3 - sigmoid\n", + "Implement the sigmoid function using numpy. \n", + "\n", + "**Instructions**: x could now be either a real number, a vector, or a matrix. The data structures we use in numpy to represent these shapes (vectors, matrices...) are called numpy arrays. You don't need to know more for now.\n", + "$$ \\text{For } x \\in \\mathbb{R}^n \\text{, } sigmoid(x) = sigmoid\\begin{pmatrix}\n", + " x_1 \\\\\n", + " x_2 \\\\\n", + " ... \\\\\n", + " x_n \\\\\n", + "\\end{pmatrix} = \\begin{pmatrix}\n", + " \\frac{1}{1+e^{-x_1}} \\\\\n", + " \\frac{1}{1+e^{-x_2}} \\\\\n", + " ... \\\\\n", + " \\frac{1}{1+e^{-x_n}} \\\\\n", + "\\end{pmatrix}\\tag{1} $$" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "fcab43fa930612b05f46fdd1421443db", + "grade": false, + "grade_id": "cell-4c5ca880d9cf9642", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: sigmoid\n", + "\n", + "def sigmoid(x):\n", + " \"\"\"\n", + " Compute the sigmoid of x\n", + "\n", + " Arguments:\n", + " x -- A scalar or numpy array of any size\n", + "\n", + " Return:\n", + " s -- sigmoid(x)\n", + " \"\"\"\n", + " \n", + " # (≈ 1 line of code)\n", + " # s = \n", + " # YOUR CODE STARTS HERE\n", + " s=1/(1+np.exp(-x))\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return s" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "7d6c9b80614b72a798e6df324bf20051", + "grade": true, + "grade_id": "cell-215cfe583f712716", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigmoid(t_x) = [0.73105858 0.88079708 0.95257413]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_x = np.array([1, 2, 3])\n", + "print(\"sigmoid(t_x) = \" + str(sigmoid(t_x)))\n", + "\n", + "sigmoid_test(sigmoid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.2 - Sigmoid Gradient\n", + "\n", + "As you've seen in lecture, you will need to compute gradients to optimize loss functions using backpropagation. Let's code your first gradient function.\n", + "\n", + "\n", + "### Exercise 4 - sigmoid_derivative\n", + "Implement the function sigmoid_grad() to compute the gradient of the sigmoid function with respect to its input x. The formula is: \n", + "\n", + "$$sigmoid\\_derivative(x) = \\sigma'(x) = \\sigma(x) (1 - \\sigma(x))\\tag{2}$$\n", + "\n", + "You often code this function in two steps:\n", + "1. Set s to be the sigmoid of x. You might find your sigmoid(x) function useful.\n", + "2. Compute $\\sigma'(x) = s(1-s)$" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "345fa4e729d4a65fc75c7b67b571b053", + "grade": false, + "grade_id": "cell-3e66ce00e171b40b", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: sigmoid_derivative\n", + "\n", + "def sigmoid_derivative(x):\n", + " \"\"\"\n", + " Compute the gradient (also called the slope or derivative) of the sigmoid function with respect to its input x.\n", + " You can store the output of the sigmoid function into variables and then use it to calculate the gradient.\n", + " \n", + " Arguments:\n", + " x -- A scalar or numpy array\n", + "\n", + " Return:\n", + " ds -- Your computed gradient.\n", + " \"\"\"\n", + " \n", + " #(≈ 2 lines of code)\n", + " # s = \n", + " # ds = \n", + " # YOUR CODE STARTS HERE\n", + " s=1/(1+np.exp(-x))\n", + " ds=s*(1-s)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return ds" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "db2f9ff9a137194ea17617bb758e1897", + "grade": true, + "grade_id": "cell-1b027673871951a1", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigmoid_derivative(t_x) = [0.19661193 0.10499359 0.04517666]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_x = np.array([1, 2, 3])\n", + "print (\"sigmoid_derivative(t_x) = \" + str(sigmoid_derivative(t_x)))\n", + "\n", + "sigmoid_derivative_test(sigmoid_derivative)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.3 - Reshaping arrays ###\n", + "\n", + "Two common numpy functions used in deep learning are [np.shape](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html) and [np.reshape()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html). \n", + "- X.shape is used to get the shape (dimension) of a matrix/vector X. \n", + "- X.reshape(...) is used to reshape X into some other dimension. \n", + "\n", + "For example, in computer science, an image is represented by a 3D array of shape $(length, height, depth = 3)$. However, when you read an image as the input of an algorithm you convert it to a vector of shape $(length*height*3, 1)$. In other words, you \"unroll\", or reshape, the 3D array into a 1D vector.\n", + "\n", + "\n", + "\n", + "\n", + "### Exercise 5 - image2vector\n", + "Implement `image2vector()` that takes an input of shape (length, height, 3) and returns a vector of shape (length\\*height\\*3, 1). For example, if you would like to reshape an array v of shape (a, b, c) into a vector of shape (a*b,c) you would do:\n", + "``` python\n", + "v = v.reshape((v.shape[0] * v.shape[1], v.shape[2])) # v.shape[0] = a ; v.shape[1] = b ; v.shape[2] = c\n", + "```\n", + "- Please don't hardcode the dimensions of image as a constant. Instead look up the quantities you need with `image.shape[0]`, etc. \n", + "- You can use v = v.reshape(-1, 1). Just make sure you understand why it works." + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "bdcbf18137f7cfa2d6ca62c4cf5c9c5d", + "grade": false, + "grade_id": "cell-b68b7900fdd239cd", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION:image2vector\n", + "\n", + "def image2vector(image):\n", + " \"\"\"\n", + " Argument:\n", + " image -- a numpy array of shape (length, height, depth)\n", + " \n", + " Returns:\n", + " v -- a vector of shape (length*height*depth, 1)\n", + " \"\"\"\n", + " \n", + " # (≈ 1 line of code)\n", + " # v =\n", + " # YOUR CODE STARTS HERE\n", + " print(image.shape)\n", + " v=image.reshape(image.shape[0]*image.shape[1]*image.shape[2],1)\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return v" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "339250a81053c3773a053c91cc46fb41", + "grade": true, + "grade_id": "cell-3b78eb8b041424f7", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 3, 2)\n", + "image2vector(image) = [[0.67826139]\n", + " [0.29380381]\n", + " [0.90714982]\n", + " [0.52835647]\n", + " [0.4215251 ]\n", + " [0.45017551]\n", + " [0.92814219]\n", + " [0.96677647]\n", + " [0.85304703]\n", + " [0.52351845]\n", + " [0.19981397]\n", + " [0.27417313]\n", + " [0.60659855]\n", + " [0.00533165]\n", + " [0.10820313]\n", + " [0.49978937]\n", + " [0.34144279]\n", + " [0.94630077]]\n", + "(3, 3, 2)\n", + "(3, 3, 2)\n", + "(3, 3, 2)\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "# This is a 3 by 3 by 2 array, typically images will be (num_px_x, num_px_y,3) where 3 represents the RGB values\n", + "t_image = np.array([[[ 0.67826139, 0.29380381],\n", + " [ 0.90714982, 0.52835647],\n", + " [ 0.4215251 , 0.45017551]],\n", + "\n", + " [[ 0.92814219, 0.96677647],\n", + " [ 0.85304703, 0.52351845],\n", + " [ 0.19981397, 0.27417313]],\n", + "\n", + " [[ 0.60659855, 0.00533165],\n", + " [ 0.10820313, 0.49978937],\n", + " [ 0.34144279, 0.94630077]]])\n", + "\n", + "print (\"image2vector(image) = \" + str(image2vector(t_image)))\n", + "\n", + "image2vector_test(image2vector)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 1.4 - Normalizing rows\n", + "\n", + "Another common technique we use in Machine Learning and Deep Learning is to normalize our data. It often leads to a better performance because gradient descent converges faster after normalization. Here, by normalization we mean changing x to $ \\frac{x}{\\| x\\|} $ (dividing each row vector of x by its norm).\n", + "\n", + "For example, if \n", + "$$x = \\begin{bmatrix}\n", + " 0 & 3 & 4 \\\\\n", + " 2 & 6 & 4 \\\\\n", + "\\end{bmatrix}\\tag{3}$$ \n", + "then \n", + "$$\\| x\\| = \\text{np.linalg.norm(x, axis=1, keepdims=True)} = \\begin{bmatrix}\n", + " 5 \\\\\n", + " \\sqrt{56} \\\\\n", + "\\end{bmatrix}\\tag{4} $$\n", + "and\n", + "$$ x\\_normalized = \\frac{x}{\\| x\\|} = \\begin{bmatrix}\n", + " 0 & \\frac{3}{5} & \\frac{4}{5} \\\\\n", + " \\frac{2}{\\sqrt{56}} & \\frac{6}{\\sqrt{56}} & \\frac{4}{\\sqrt{56}} \\\\\n", + "\\end{bmatrix}\\tag{5}$$ \n", + "\n", + "Note that you can divide matrices of different sizes and it works fine: this is called broadcasting and you're going to learn about it in part 5.\n", + "\n", + "With `keepdims=True` the result will broadcast correctly against the original x.\n", + "\n", + "`axis=1` means you are going to get the norm in a row-wise manner. If you need the norm in a column-wise way, you would need to set `axis=0`. \n", + "\n", + "numpy.linalg.norm has another parameter `ord` where we specify the type of normalization to be done (in the exercise below you'll do 2-norm). To get familiar with the types of normalization you can visit [numpy.linalg.norm](https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html)\n", + "\n", + "\n", + "### Exercise 6 - normalize_rows\n", + "Implement normalizeRows() to normalize the rows of a matrix. After applying this function to an input matrix x, each row of x should be a vector of unit length (meaning length 1).\n", + "\n", + "**Note**: Don't try to use `x /= x_norm`. For the matrix division numpy must broadcast the x_norm, which is not supported by the operant `/=`" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "dc112a436b66b6526a5fbfe1e7822ba8", + "grade": false, + "grade_id": "cell-5a030834cece94f4", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: normalize_rows\n", + "\n", + "def normalize_rows(x):\n", + " \"\"\"\n", + " Implement a function that normalizes each row of the matrix x (to have unit length).\n", + " \n", + " Argument:\n", + " x -- A numpy matrix of shape (n, m)\n", + " \n", + " Returns:\n", + " x -- The normalized (by row) numpy matrix. You are allowed to modify x.\n", + " \"\"\"\n", + " \n", + " #(≈ 2 lines of code)\n", + " # Compute x_norm as the norm 2 of x. Use np.linalg.norm(..., ord = 2, axis = ..., keepdims = True)\n", + " # x_norm =\n", + " # Divide x by its norm.\n", + " # x =\n", + " # YOUR CODE STARTS HERE\n", + "# MY METHOD:\n", + "# sq_x=x**2\n", + "# sq_x=sq_x.sum(axis=1,keepdims=True)\n", + "# sq_x.reshape(x.shape[0],1)\n", + "# x_norm=np.sqrt(sq_x)\n", + "# x_norm.reshape(x.shape[0],1)\n", + "# x=x*(1/x_norm)\n", + " \n", + " from numpy import linalg as LA\n", + " x_norm=LA.norm(x,axis=1,keepdims=True)\n", + " x=x*(1/x_norm)\n", + "\n", + " \n", + " # YOUR CODE ENDS HERE\n", + "\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "4c780d41666f3144b0d68804c2df2e21", + "grade": true, + "grade_id": "cell-0910101c4de92095", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "normalizeRows(x) = [[0. 0.6 0.8 ]\n", + " [0.13736056 0.82416338 0.54944226]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "x = np.array([[0, 3, 4],\n", + " [1, 6, 4]])\n", + "print(\"normalizeRows(x) = \" + str(normalize_rows(x)))\n", + "\n", + "normalizeRows_test(normalize_rows)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**:\n", + "In normalize_rows(), you can try to print the shapes of x_norm and x, and then rerun the assessment. You'll find out that they have different shapes. This is normal given that x_norm takes the norm of each row of x. So x_norm has the same number of rows but only 1 column. So how did it work when you divided x by x_norm? This is called broadcasting and we'll talk about it now! " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \n", + "### Exercise 7 - softmax\n", + "Implement a softmax function using numpy. You can think of softmax as a normalizing function used when your algorithm needs to classify two or more classes. You will learn more about softmax in the second course of this specialization.\n", + "\n", + "**Instructions**:\n", + "- $\\text{for } x \\in \\mathbb{R}^{1\\times n} \\text{, }$\n", + "\n", + "\\begin{align*}\n", + " softmax(x) &= softmax\\left(\\begin{bmatrix}\n", + " x_1 &&\n", + " x_2 &&\n", + " ... &&\n", + " x_n \n", + "\\end{bmatrix}\\right) \\\\&= \\begin{bmatrix}\n", + " \\frac{e^{x_1}}{\\sum_{j}e^{x_j}} &&\n", + " \\frac{e^{x_2}}{\\sum_{j}e^{x_j}} &&\n", + " ... &&\n", + " \\frac{e^{x_n}}{\\sum_{j}e^{x_j}} \n", + "\\end{bmatrix} \n", + "\\end{align*}\n", + "\n", + "- $\\text{for a matrix } x \\in \\mathbb{R}^{m \\times n} \\text{, $x_{ij}$ maps to the element in the $i^{th}$ row and $j^{th}$ column of $x$, thus we have: }$ \n", + "\n", + "\\begin{align*}\n", + "softmax(x) &= softmax\\begin{bmatrix}\n", + " x_{11} & x_{12} & x_{13} & \\dots & x_{1n} \\\\\n", + " x_{21} & x_{22} & x_{23} & \\dots & x_{2n} \\\\\n", + " \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n", + " x_{m1} & x_{m2} & x_{m3} & \\dots & x_{mn}\n", + " \\end{bmatrix} \\\\ \\\\&= \n", + " \\begin{bmatrix}\n", + " \\frac{e^{x_{11}}}{\\sum_{j}e^{x_{1j}}} & \\frac{e^{x_{12}}}{\\sum_{j}e^{x_{1j}}} & \\frac{e^{x_{13}}}{\\sum_{j}e^{x_{1j}}} & \\dots & \\frac{e^{x_{1n}}}{\\sum_{j}e^{x_{1j}}} \\\\\n", + " \\frac{e^{x_{21}}}{\\sum_{j}e^{x_{2j}}} & \\frac{e^{x_{22}}}{\\sum_{j}e^{x_{2j}}} & \\frac{e^{x_{23}}}{\\sum_{j}e^{x_{2j}}} & \\dots & \\frac{e^{x_{2n}}}{\\sum_{j}e^{x_{2j}}} \\\\\n", + " \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n", + " \\frac{e^{x_{m1}}}{\\sum_{j}e^{x_{mj}}} & \\frac{e^{x_{m2}}}{\\sum_{j}e^{x_{mj}}} & \\frac{e^{x_{m3}}}{\\sum_{j}e^{x_{mj}}} & \\dots & \\frac{e^{x_{mn}}}{\\sum_{j}e^{x_{mj}}}\n", + "\\end{bmatrix} \\\\ \\\\ &= \\begin{pmatrix}\n", + " softmax\\text{(first row of x)} \\\\\n", + " softmax\\text{(second row of x)} \\\\\n", + " \\vdots \\\\\n", + " softmax\\text{(last row of x)} \\\\\n", + "\\end{pmatrix} \n", + "\\end{align*}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Notes:**\n", + "Note that later in the course, you'll see \"m\" used to represent the \"number of training examples\", and each training example is in its own column of the matrix. Also, each feature will be in its own row (each row has data for the same feature). \n", + "Softmax should be performed for all features of each training example, so softmax would be performed on the columns (once we switch to that representation later in this course).\n", + "\n", + "However, in this coding practice, we're just focusing on getting familiar with Python, so we're using the common math notation $m \\times n$ \n", + "where $m$ is the number of rows and $n$ is the number of columns." + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "5100054e6e6ea2c9a6343b43406cf909", + "grade": false, + "grade_id": "cell-f41746c0a00bd2fc", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: softmax\n", + "\n", + "def softmax(x):\n", + " \"\"\"Calculates the softmax for each row of the input x.\n", + "\n", + " Your code should work for a row vector and also for matrices of shape (m,n).\n", + "\n", + " Argument:\n", + " x -- A numpy matrix of shape (m,n)\n", + "\n", + " Returns:\n", + " s -- A numpy matrix equal to the softmax of x, of shape (m,n)\n", + " \"\"\"\n", + " \n", + " #(≈ 3 lines of code)\n", + " # Apply exp() element-wise to x. Use np.exp(...).\n", + " # x_exp = ...\n", + "\n", + " # Create a vector x_sum that sums each row of x_exp. Use np.sum(..., axis = 1, keepdims = True).\n", + " # x_sum = ...\n", + " \n", + " # Compute softmax(x) by dividing x_exp by x_sum. It should automatically use numpy broadcasting.\n", + " # s = ...\n", + " \n", + " # YOUR CODE STARTS HERE\n", + " x_exp=np.exp(x)\n", + " x_sum=x_exp.sum(axis=1,keepdims=True)\n", + " s=x_exp*(1/x_sum)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return s" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "e598fb22ddfec51bbdb6d08af1076cc5", + "grade": true, + "grade_id": "cell-6f8e1f025948128c", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "softmax(x) = [[9.80897665e-01 8.94462891e-04 1.79657674e-02 1.21052389e-04\n", + " 1.21052389e-04]\n", + " [8.78679856e-01 1.18916387e-01 8.01252314e-04 8.01252314e-04\n", + " 8.01252314e-04]]\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "t_x = np.array([[9, 2, 5, 0, 0],\n", + " [7, 5, 0, 0 ,0]])\n", + "print(\"softmax(x) = \" + str(softmax(t_x)))\n", + "\n", + "softmax_test(softmax)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Notes\n", + "- If you print the shapes of x_exp, x_sum and s above and rerun the assessment cell, you will see that x_sum is of shape (2,1) while x_exp and s are of shape (2,5). **x_exp/x_sum** works due to python broadcasting.\n", + "\n", + "Congratulations! You now have a pretty good understanding of python numpy and have implemented a few useful functions that you will be using in deep learning." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "What you need to remember:\n", + " \n", + "- np.exp(x) works for any np.array x and applies the exponential function to every coordinate\n", + "- the sigmoid function and its gradient\n", + "- image2vector is commonly used in deep learning\n", + "- np.reshape is widely used. In the future, you'll see that keeping your matrix/vector dimensions straight will go toward eliminating a lot of bugs. \n", + "- numpy has efficient built-in functions\n", + "- broadcasting is extremely useful" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2 - Vectorization\n", + "\n", + "\n", + "In deep learning, you deal with very large datasets. Hence, a non-computationally-optimal function can become a huge bottleneck in your algorithm and can result in a model that takes ages to run. To make sure that your code is computationally efficient, you will use vectorization. For example, try to tell the difference between the following implementations of the dot/outer/elementwise product." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]\n", + "x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]\n", + "\n", + "### CLASSIC DOT PRODUCT OF VECTORS IMPLEMENTATION ###\n", + "tic = time.process_time()\n", + "dot = 0\n", + "\n", + "for i in range(len(x1)):\n", + " dot += x1[i] * x2[i]\n", + "toc = time.process_time()\n", + "print (\"dot = \" + str(dot) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")\n", + "\n", + "### CLASSIC OUTER PRODUCT IMPLEMENTATION ###\n", + "tic = time.process_time()\n", + "outer = np.zeros((len(x1), len(x2))) # we create a len(x1)*len(x2) matrix with only zeros\n", + "\n", + "for i in range(len(x1)):\n", + " for j in range(len(x2)):\n", + " outer[i,j] = x1[i] * x2[j]\n", + "toc = time.process_time()\n", + "print (\"outer = \" + str(outer) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")\n", + "\n", + "### CLASSIC ELEMENTWISE IMPLEMENTATION ###\n", + "tic = time.process_time()\n", + "mul = np.zeros(len(x1))\n", + "\n", + "for i in range(len(x1)):\n", + " mul[i] = x1[i] * x2[i]\n", + "toc = time.process_time()\n", + "print (\"elementwise multiplication = \" + str(mul) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")\n", + "\n", + "### CLASSIC GENERAL DOT PRODUCT IMPLEMENTATION ###\n", + "W = np.random.rand(3,len(x1)) # Random 3*len(x1) numpy array\n", + "tic = time.process_time()\n", + "gdot = np.zeros(W.shape[0])\n", + "\n", + "for i in range(W.shape[0]):\n", + " for j in range(len(x1)):\n", + " gdot[i] += W[i,j] * x1[j]\n", + "toc = time.process_time()\n", + "print (\"gdot = \" + str(gdot) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]\n", + "x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]\n", + "\n", + "### VECTORIZED DOT PRODUCT OF VECTORS ###\n", + "tic = time.process_time()\n", + "dot = np.dot(x1,x2)\n", + "toc = time.process_time()\n", + "print (\"dot = \" + str(dot) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")\n", + "\n", + "### VECTORIZED OUTER PRODUCT ###\n", + "tic = time.process_time()\n", + "outer = np.outer(x1,x2)\n", + "toc = time.process_time()\n", + "print (\"outer = \" + str(outer) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")\n", + "\n", + "### VECTORIZED ELEMENTWISE MULTIPLICATION ###\n", + "tic = time.process_time()\n", + "mul = np.multiply(x1,x2)\n", + "toc = time.process_time()\n", + "print (\"elementwise multiplication = \" + str(mul) + \"\\n ----- Computation time = \" + str(1000*(toc - tic)) + \"ms\")\n", + "\n", + "### VECTORIZED GENERAL DOT PRODUCT ###\n", + "tic = time.process_time()\n", + "dot = np.dot(W,x1)\n", + "toc = time.process_time()\n", + "print (\"gdot = \" + str(dot) + \"\\n ----- Computation time = \" + str(1000 * (toc - tic)) + \"ms\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you may have noticed, the vectorized implementation is much cleaner and more efficient. For bigger vectors/matrices, the differences in running time become even bigger. \n", + "\n", + "**Note** that `np.dot()` performs a matrix-matrix or matrix-vector multiplication. This is different from `np.multiply()` and the `*` operator (which is equivalent to `.*` in Matlab/Octave), which performs an element-wise multiplication." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \n", + "### 2.1 Implement the L1 and L2 loss functions\n", + "\n", + "\n", + "### Exercise 8 - L1 \n", + "Implement the numpy vectorized version of the L1 loss. You may find the function abs(x) (absolute value of x) useful.\n", + "\n", + "**Reminder**:\n", + "- The loss is used to evaluate the performance of your model. The bigger your loss is, the more different your predictions ($ \\hat{y} $) are from the true values ($y$). In deep learning, you use optimization algorithms like Gradient Descent to train your model and to minimize the cost.\n", + "- L1 loss is defined as:\n", + "$$\\begin{align*} & L_1(\\hat{y}, y) = \\sum_{i=0}^{m-1}|y^{(i)} - \\hat{y}^{(i)}| \\end{align*}\\tag{6}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "2c496fe0b5fb6fe1580162305cf97387", + "grade": false, + "grade_id": "cell-410accbd4d9a1fc2", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: L1\n", + "\n", + "def L1(yhat, y):\n", + " \"\"\"\n", + " Arguments:\n", + " yhat -- vector of size m (predicted labels)\n", + " y -- vector of size m (true labels)\n", + " \n", + " Returns:\n", + " loss -- the value of the L1 loss function defined above\n", + " \"\"\"\n", + " \n", + " #(≈ 1 line of code)\n", + " # loss = \n", + " # YOUR CODE STARTS HERE\n", + " loss=abs(y-yhat)\n", + " loss=loss.sum()\n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "7435251c8f0959006b7034fd1eb9a2d3", + "grade": true, + "grade_id": "cell-44ac3b50c1fba7a0", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L1 = 1.1\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "yhat = np.array([.9, 0.2, 0.1, .4, .9])\n", + "y = np.array([1, 0, 0, 1, 1])\n", + "print(\"L1 = \" + str(L1(yhat, y)))\n", + "\n", + "L1_test(L1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Exercise 9 - L2\n", + "Implement the numpy vectorized version of the L2 loss. There are several way of implementing the L2 loss but you may find the function np.dot() useful. As a reminder, if $x = [x_1, x_2, ..., x_n]$, then `np.dot(x,x)` = $\\sum_{j=1}^n x_j^{2}$. \n", + "\n", + "- L2 loss is defined as $$\\begin{align*} & L_2(\\hat{y},y) = \\sum_{i=0}^{m-1}(y^{(i)} - \\hat{y}^{(i)})^2 \\end{align*}\\tag{7}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": { + "deletable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "d806d7037061895561c70f6abb03380e", + "grade": false, + "grade_id": "cell-a2624d0db4d22322", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "# GRADED FUNCTION: L2\n", + "\n", + "def L2(yhat, y):\n", + " \"\"\"\n", + " Arguments:\n", + " yhat -- vector of size m (predicted labels)\n", + " y -- vector of size m (true labels)\n", + " \n", + " Returns:\n", + " loss -- the value of the L2 loss function defined above\n", + " \"\"\"\n", + " \n", + " #(≈ 1 line of code)\n", + " # loss = ...\n", + " # YOUR CODE STARTS HERE\n", + " loss=y-yhat\n", + " loss=np.dot(loss,loss)\n", + " \n", + " # YOUR CODE ENDS HERE\n", + " \n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": { + "deletable": false, + "editable": false, + "nbgrader": { + "cell_type": "code", + "checksum": "ef616282fe941f332052dbb8641e9aa8", + "grade": true, + "grade_id": "cell-e7809ad65b5fe0ab", + "locked": true, + "points": 10, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L2 = 0.43\n", + "\u001b[92m All tests passed.\n" + ] + } + ], + "source": [ + "yhat = np.array([.9, 0.2, 0.1, .4, .9])\n", + "y = np.array([1, 0, 0, 1, 1])\n", + "\n", + "print(\"L2 = \" + str(L2(yhat, y)))\n", + "\n", + "L2_test(L2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Congratulations on completing this assignment. We hope that this little warm-up exercise helps you in the future assignments, which will be more exciting and interesting!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "What to remember:\n", + " \n", + "- Vectorization is very important in deep learning. It provides computational efficiency and clarity.\n", + "- You have reviewed the L1 and L2 loss.\n", + "- You are familiar with many numpy functions such as np.sum, np.dot, np.multiply, np.maximum, etc..." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Notes/Course1.jpeg b/Notes/Course1.jpeg new file mode 100644 index 0000000..c76078c Binary files /dev/null and b/Notes/Course1.jpeg differ diff --git a/Notes/Course_1.jpeg b/Notes/Course_1.jpeg new file mode 100644 index 0000000..38178d8 Binary files /dev/null and b/Notes/Course_1.jpeg differ diff --git a/Notes/course1.jpeg b/Notes/course1.jpeg new file mode 100644 index 0000000..abe2266 Binary files /dev/null and b/Notes/course1.jpeg differ diff --git a/Notes/course1`.jpeg b/Notes/course1`.jpeg new file mode 100644 index 0000000..d271efb Binary files /dev/null and b/Notes/course1`.jpeg differ diff --git a/Notes/course1``.jpeg b/Notes/course1``.jpeg new file mode 100644 index 0000000..74498eb Binary files /dev/null and b/Notes/course1``.jpeg differ diff --git a/Notes/course_1.jpeg b/Notes/course_1.jpeg new file mode 100644 index 0000000..18d190d Binary files /dev/null and b/Notes/course_1.jpeg differ