{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MNIST with octopusal networks\n",
    "\n",
    "If you haven't already, I suggest you to read [the description of octopusal networks](https://nbviewer.jupyter.org/github/marconunnari/octopusal_networks/blob/master/OctopusalNetworks.ipynb).\n",
    "\n",
    "In this notebook we use octopusal networks to recognize handwritten digits contained in the [MINST database](https://en.wikipedia.org/wiki/MNIST_database).\n",
    "\n",
    "To achieve these, the strategy that has proved most successful is to use the convolutional base of a [Convolutional Neural Network](https://en.wikipedia.org/wiki/Convolutional_neural_network) to extract features from the images and then give these features to an octopusal network that will classify them.\n",
    "\n",
    "This may seem cheating but I think that before that the information arrive to the mind it is processed by some filters in the senses or somewhere else. So the convolution base in this example would act as the sensory system.\n",
    "\n",
    "At the end we get a result of 86% accuracy by training the model only on 500 training examples and without tuning very well the hyperparameters. The goal is just to show how an octopusal network can recognize patterns given some features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolution Neural Network\n",
    "\n",
    "Here we train a simple convolutional neural network with keras that get to 99% of accuracy on the MNIST and then save the model to a file. Uncomment the last line to generate the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import layers\n",
    "from keras import models\n",
    "\n",
    "def train_conv_nn():\n",
    "    model = models.Sequential()\n",
    "    model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))\n",
    "    model.add(layers.MaxPooling2D((2, 2)))\n",
    "    model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "    model.add(layers.MaxPooling2D((2, 2)))\n",
    "    model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "\n",
    "    model.add(layers.Flatten())\n",
    "    model.add(layers.Dense(64, activation='relu'))\n",
    "    model.add(layers.Dense(10, activation='softmax'))\n",
    "\n",
    "    from keras.datasets import mnist\n",
    "    from keras.utils import to_categorical\n",
    "\n",
    "    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
    "    train_images = train_images.reshape((60000, 28, 28, 1))\n",
    "    train_images = train_images.astype('float32') / 255\n",
    "\n",
    "    test_images = test_images.reshape((10000, 28, 28, 1))\n",
    "    test_images = test_images.astype('float32') / 255\n",
    "\n",
    "    train_labels = to_categorical(train_labels)\n",
    "    test_labels = to_categorical(test_labels)\n",
    "\n",
    "    model.compile(optimizer='rmsprop',\n",
    "                  loss='categorical_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "    model.fit(train_images, train_labels, epochs=5, batch_size=64)\n",
    "    model.save('./cnn_minst.h5')\n",
    "    \n",
    "#train_conv_nn()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features extraction\n",
    "\n",
    "Here we take the convolutional base of the model trained (so without the densely connected layers) and feed it with the original images of the digits. Then we convert the features extracted in a clause 'where' usable by the octopusal network.\n",
    "\n",
    "The main function here is 'extract_data' that returns an object where we store the train and test datasets in a useful fashion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.models import Model\n",
    "from keras.datasets import mnist\n",
    "from keras.models import load_model\n",
    "\n",
    "np.set_printoptions(suppress=True)\n",
    "\n",
    "model = load_model('./cnn_minst.h5')\n",
    "layer_name = 'flatten_1'\n",
    "conv_base = Model(inputs=model.input,\n",
    "                             outputs=model.get_layer(layer_name).output)\n",
    "\n",
    "\n",
    "def features_to_where(features, threshold):\n",
    "    where = []\n",
    "    for i in range(0, len(features)):\n",
    "        value = features[i]\n",
    "        if (value > threshold):\n",
    "            where.append((0, i))\n",
    "    return where\n",
    "\n",
    "\n",
    "def show_image(image, label):\n",
    "    plt.title(f'Image: {label}')\n",
    "    plt.imshow(image, cmap=plt.cm.binary)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "class MnistDataItem:\n",
    "    def __init__(self, image, label, where):\n",
    "        self.image = image\n",
    "        self.label = label\n",
    "        self.where = where\n",
    "\n",
    "\n",
    "class MnistDataSet:\n",
    "    def __init__(self, size, images, labels, wheres):\n",
    "        self.size = size\n",
    "        self.images = images\n",
    "        self.labels = labels\n",
    "        self.wheres = wheres\n",
    "\n",
    "    def get_item(self, index):\n",
    "        return MnistDataItem(\n",
    "            self.images[index],\n",
    "            self.labels[index],\n",
    "            self.wheres[index]\n",
    "        )\n",
    "\n",
    "\n",
    "class MnistData:\n",
    "    def __init__(self, train, test):\n",
    "        self.train = train\n",
    "        self.test = test\n",
    "\n",
    "\n",
    "def extract_features(images, labels, size, threshold):\n",
    "    images_mod = images.reshape((images.shape[0], 28, 28, 1)).astype('float32') / 255\n",
    "    wheres = []\n",
    "    for index in range(0, size):\n",
    "        label = labels[index]\n",
    "        image = images[index]\n",
    "\n",
    "        image_mod = images_mod[index]\n",
    "\n",
    "        features = conv_base.predict(image_mod[None, :, :, :])\n",
    "        features = features * 100\n",
    "        features = features.astype(int)\n",
    "        features = features.reshape((576))\n",
    "\n",
    "        where = features_to_where(features, threshold)\n",
    "        wheres.append(where)\n",
    "    return MnistDataSet(size, images[:size], labels[:size], wheres)\n",
    "\n",
    "    \n",
    "def extract_data(size_train, size_test):\n",
    "    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
    "    train = extract_features(train_images, train_labels, size_train, 50)\n",
    "    test = extract_features(test_images, test_labels, size_test, 50)\n",
    "    return MnistData(train, test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Octopusal Network\n",
    "\n",
    "To classify the MNIST we import the octopusal networks and we introduce three new features: Freezing, Custom emojis and Emispheres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from basic_octopusal_networks import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Freezing\n",
    "\n",
    "We add the concept of freezing that prevent the soreness of tentacles to increase if we set the property `freeze_connections` to `True`. This is useful in the testing stage because we don't want the beach to learn anymore. So when `freeze_connections` is `True` the beach can't form new connections and it will only apply the knowledge acquired in the past."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TentacleWithFreezing(TentacleWithSoreness):\n",
    "\n",
    "    freeze_connections = False\n",
    "\n",
    "    def __init__(self, id, owner, connected):\n",
    "        super().__init__(id, owner, connected)\n",
    "\n",
    "    def shock(self):\n",
    "        if self.connected.awake:\n",
    "            if not TentacleWithFreezing.freeze_connections:\n",
    "                self.soreness += 1\n",
    "        else:\n",
    "            self.connected.shocked(self.soreness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BeachWithFreezing(BeachWithListeners):\n",
    "    \n",
    "    def __init__(self, width, height, shocks_threshold=80,\n",
    "                 smell_threshold=50, tiredness_threshold=5, recovery_threshold=5):\n",
    "        super().__init__(width, height, shocks_threshold, smell_threshold,\n",
    "                         tiredness_threshold, recovery_threshold)\n",
    "\n",
    "    def create_tentacle(self, id, owner, connected):\n",
    "        return TentacleWithFreezing(id=id, owner=owner, connected=connected)\n",
    "\n",
    "    def animate(self, where=None, iterations=10, show=True, freeze_connections=False):\n",
    "        TentacleWithFreezing.freeze_connections = freeze_connections\n",
    "        super().animate(where, iterations, show)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom emojis\n",
    "\n",
    "We add the possibility to change the emoji when the octopuses are awake. So when we print the beach instead of seeing 💡 for the octopuses awake we'll see the custom emoji. We add also a method on the beach to customize the emoji for more octopuses at the same time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OctopusWithCustomEmoji(OctopusWithListeners):\n",
    "\n",
    "    def __init__(self, id, environment):\n",
    "        super().__init__(id, environment)\n",
    "        self.emoji = '💡'\n",
    "\n",
    "    def set_emoji(self, emoji):\n",
    "        self.emoji = emoji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BeachWithCustomEmojis(BeachWithFreezing):\n",
    "\n",
    "    def __init__(self, width, height, shocks_threshold=80,\n",
    "                 smell_threshold=50, tiredness_threshold=5, recovery_threshold=5):\n",
    "        super().__init__(width, height, shocks_threshold, smell_threshold,\n",
    "                         tiredness_threshold, recovery_threshold)\n",
    "\n",
    "    def create_octopus(self, id):\n",
    "        return OctopusWithCustomEmoji(id=id, environment=self)\n",
    "\n",
    "    def set_emoji(self, where, emoji):\n",
    "        for x, y in where:\n",
    "            octopus = self.get(x, y)\n",
    "            octopus.set_emoji(emoji)\n",
    "\n",
    "    def __str__(self):\n",
    "        result = '\\n'\n",
    "        for x in range(0, self.height):\n",
    "            for y in range(0, self.width):\n",
    "                octopus = self.octopuses[x * self.width + y]\n",
    "                result += octopus.emoji if octopus.awake else '🐙'\n",
    "            result += '\\n'\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hemispheres\n",
    "\n",
    "Here we introduce the BeachWithHemispheres. In this class we don't connect the octopuses neighbours, but we divide the beach in two parts and we connect each octopus of the first part to each octopus on the other part. We also change the method `__str__` to show better this division adding a row of 🔗(link emojis) that divides the two hemispheres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BeachWithHemispheres(BeachWithCustomEmojis):\n",
    "\n",
    "    def __init__(self, width, height, shocks_threshold=80,\n",
    "                 smell_threshold=50, tiredness_threshold=5, recovery_threshold=5):\n",
    "        super().__init__(width, height, shocks_threshold, smell_threshold,\n",
    "                         tiredness_threshold, recovery_threshold)\n",
    "        self.divide_hemispheres()\n",
    "        self.connect_hemispheres()\n",
    "\n",
    "    def connect_neighbours(self):\n",
    "        pass\n",
    "\n",
    "    def divide_hemispheres(self):\n",
    "        half_row = self.height // 2\n",
    "        half_index = half_row * self.width\n",
    "        self.hemisphere1 = self.octopuses[:half_index]\n",
    "        self.hemisphere2 = self.octopuses[half_index:]\n",
    "\n",
    "    def connect_hemispheres(self):\n",
    "        i = 0\n",
    "        for octopus1 in self.hemisphere1:\n",
    "            for octopus2 in self.hemisphere2:\n",
    "                tentacle = self.create_tentacle(id=i, owner=octopus1, connected=octopus2)\n",
    "                i += 1\n",
    "\n",
    "    def __str__(self):\n",
    "        result = '\\n'\n",
    "        max_width = self.width if self.width < 40 else 40\n",
    "        counter = 1\n",
    "        half_row = self.height // 2\n",
    "        for x in range(0, self.height):\n",
    "            if x == half_row:\n",
    "                result += '\\n'\n",
    "                result += '🔗' * max_width\n",
    "                result += '\\n'\n",
    "                counter = 1\n",
    "            for y in range(0, self.width):\n",
    "                octopus = self.octopuses[x * self.width + y]\n",
    "                result += octopus.emoji if octopus.awake else '🐙'\n",
    "                counter += 1\n",
    "                if counter % (max_width + 1) == 0:\n",
    "                    counter = 1\n",
    "                    result += '\\n'\n",
    "        result += '\\n'\n",
    "        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training stage\n",
    "\n",
    "To recognize the digits we build a beach with two rows. The first row is the first hemisphere on which we'll show the features. The second row is the second hemisphere where we assign the first 50 octopuses to the recognition of the digit zero, the second 50 octopuses to the recognition of the digit two and so on. To show this better we change some emojis so that the octopuses of the group dedicated at the digit one when awake will print 1️⃣ and the same for the other digits.\n",
    "\n",
    "So for each training example we activate the beach with the features of the digit and the corresponding zone on the second hemisphere. In this way we connect the inputs with the expected outputs.\n",
    "\n",
    "Eventually we attach a listener to each zone of the second hemisphere that will determine the prediction by detecting which digit pattern was awakened first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from progress_bar import ProgressBar\n",
    "\n",
    "def create_mnist_beach():\n",
    "    beach = BeachWithHemispheres(\n",
    "        width=576, height=2,\n",
    "        shocks_threshold=150000,\n",
    "        tiredness_threshold=50,\n",
    "        smell_threshold=200,\n",
    "    )\n",
    "\n",
    "    second_row = [(1, y) for y in range(0, 576)]\n",
    "    zero = second_row[0:50]\n",
    "    one = second_row[50:100]\n",
    "    two = second_row[100:150]\n",
    "    three = second_row[150:200]\n",
    "    four = second_row[200:250]\n",
    "    five = second_row[250:300]\n",
    "    six = second_row[300:350]\n",
    "    seven = second_row[350:400]\n",
    "    eight = second_row[400:450]\n",
    "    nine = second_row[450:500]\n",
    "    digits = [zero, one, two, three, four, five, six, seven, eight, nine]\n",
    "\n",
    "    beach.set_emoji(digits[0], '0️⃣')\n",
    "    beach.set_emoji(digits[1], '1️⃣')\n",
    "    beach.set_emoji(digits[2], '2️⃣')\n",
    "    beach.set_emoji(digits[3], '3️⃣')\n",
    "    beach.set_emoji(digits[4], '4️⃣')\n",
    "    beach.set_emoji(digits[5], '5️⃣')\n",
    "    beach.set_emoji(digits[6], '6️⃣')\n",
    "    beach.set_emoji(digits[7], '7️⃣')\n",
    "    beach.set_emoji(digits[8], '8️⃣')\n",
    "    beach.set_emoji(digits[9], '9️⃣')\n",
    "    \n",
    "    return (beach, digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see in the next example that in the first emisphere of the beach (at the top) we have the octopuses awake that corresponds to the features extracted by the convolutional base and the in the second emisphere the group dedicated to the digit 5 awakened."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAEICAYAAACQ6CLfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAEONJREFUeJzt3XuMXPV5xvHvg7mbq+OFLI6LE0CoFigGDbiqKzBJSiAR2PxBhEvBoAijFnAj2UodUIpbJRIiFxJiGmQIBaTYqevgAhIKN4EoRUUegmVMiUugCxgce4nDvS1g3v4xZ6OJ2fnNeG5n1r/nI41m9rznzHn3aJ89M3POmZ8iAjPLz15lN2Bm5XD4zTLl8JtlyuE3y5TDb5Yph98sUw6/WaYc/glK0oikL5Tdx+6QNENSSHqn7vbNsvvK1d5lN2BZOiwiPiy7idx5z78HkHSJpH+XdIOkNyS9KOlPi+mvSNouaWHd/F+W9LSkt4r68l2e72JJL0n6raRv1r/KkLSXpGWSXijqayRN6fOvbF3g8O85ZgMbgU8Aq4CfAacAxwJ/CayQdFAx77vAxcBhwJeBv5I0H0DSTOAfgQuBYeBQYFrdehYD84HTgaOA3wE3jRUlbZT0F016fUnSFkn/JGlq27+xdSYifJuAN2AE+ELx+BLg+braiUAAR9ZN+y0wq8Fz/QC4oXj8d8DqutqBwPt163oO+HxdfRj4ANi7hZ4PAirU3m4eCawF7i97W+Z683v+Pce2usf/AxARu047CEDSbOA64ARgX2A/4F+K+Y4CXhlbKCLek/Tbuuc5Glgn6aO6aTuphfnVVIMR8Q5QHetX0pXAVkmHRMRbrfyS1j1+2Z+nVcA9wPSIOBS4GVBR2wp8amxGSQdQeysx5hXg7Ig4rO62f0Qkg9/A2CWlSs5lPeHw5+lgYEdE/K+kU4H69+hrgXOKDwz3Bf6ePwznzcC3JR0NIGlI0rxWVipptqTjiw8NPwHcCDwaEW9245ey3ePw5+mvgX+Q9Da19/hrxgoR8SxwFbUPDLcCbwPbgf8rZvkhtVcNDxTL/we1DxsBkPSspAsbrPczwC+K59xUPOeC7v1atjtUfBBjNq7iCMEbwHER8d9l92Pd4z2/fYykcyQdKGky8F3gGWpHF2wP4vDbeOYBrxW344ALwi8R9zh+2W+WKe/5zTLV15N8pk6dGjNmzOjnKs2yMjIywuuvv97SeRMdhV/SWdQO/UwCbo2I61Lzz5gxg2q1mprFzDpQqVRanrftl/2SJlG7oONsYCawoLgoxMwmgE7e858K/DoiXoyI96mdFNLSmV5mVr5Owj+NugtAgC384aWfAEhaJKkqqTo6OtrB6sysmzoJ/3gfKnzsuGFErIyISkRUhoaGOlidmXVTJ+HfAkyv+/lT1E4KMbMJoJPwrweOk/Tp4uqvC6hd8GFmE0Dbh/oi4sPiyxjup3ao77biijAzmwA6Os4fEfcB93WpFzPrI5/ea5Yph98sUw6/WaYcfrNMOfxmmXL4zTLl8JtlyuE3y5TDb5Yph98sUw6/WaYcfrNMOfxmmXL4zTLl8JtlyuE3y5TDb5Yph98sUw6/WaYcfrNMOfxmmXL4zTLl8JtlyuE3y5TDb5Yph98sUw6/WaYcfrNMOfxmmepolF4bfDt37kzW33zzzZ6uf8WKFQ1r7733XnLZzZs3J+s33XRTsr506dKGtdWrVyeX3X///ZP1ZcuWJevXXnttsj4IOgq/pBHgbWAn8GFEVLrRlJn1Xjf2/GdExOtdeB4z6yO/5zfLVKfhD+ABSU9JWjTeDJIWSapKqo6Ojna4OjPrlk7DPyciTgbOBq6QdNquM0TEyoioRERlaGiow9WZWbd0FP6IeK243w6sA07tRlNm1ntth1/SZEkHjz0GzgQ2dasxM+utTj7tPxJYJ2nseVZFxC+60tUe5uWXX07W33///WT9iSeeSNYff/zxhrU33ngjuezatWuT9TJNnz49Wb/qqquS9XXr1jWsHXzwwcllP/vZzybrp59+erI+EbQd/oh4EUhvITMbWD7UZ5Yph98sUw6/WaYcfrNMOfxmmfIlvV3w9NNPJ+uf+9znkvVeX1Y7qCZNmpSsf+tb30rWJ0+enKxfeOGFDWtHHXVUctnDDz88WT/++OOT9YnAe36zTDn8Zply+M0y5fCbZcrhN8uUw2+WKYffLFM+zt8FRx99dLI+derUZH2Qj/PPnj07WW92PPyRRx5pWNt3332Ty1500UXJunXGe36zTDn8Zply+M0y5fCbZcrhN8uUw2+WKYffLFM+zt8FU6ZMSda/853vJOv33ntvsn7SSScl64sXL07WU2bNmpWsP/TQQ8l6s2vqN21qPJTDjTfemFzWest7frNMOfxmmXL4zTLl8JtlyuE3y5TDb5Yph98sUz7O3wfz589P1pt9r3+z4aQ3btzYsHbrrbcml126dGmy3uw4fjMnnHBCw9rKlSs7em7rTNM9v6TbJG2XtKlu2hRJD0p6vrhPf6ODmQ2cVl723w6ctcu0ZcDDEXEc8HDxs5lNIE3DHxGPATt2mTwPuKN4fAeQfl1rZgOn3Q/8joyIrQDF/RGNZpS0SFJVUnV0dLTN1ZlZt/X80/6IWBkRlYioDA0N9Xp1ZtaidsO/TdIwQHG/vXstmVk/tBv+e4CFxeOFwN3dacfM+qXpcX5Jq4G5wFRJW4BrgeuANZK+CrwMnN/LJvd0hxxySEfLH3rooW0v2+w8gAsuuCBZ32svnyc2UTUNf0QsaFD6fJd7MbM+8r9ts0w5/GaZcvjNMuXwm2XK4TfLlC/p3QMsX768Ye2pp55KLvvoo48m682+uvvMM89M1m1wec9vlimH3yxTDr9Zphx+s0w5/GaZcvjNMuXwm2XKx/n3AKmv177llluSy5588snJ+mWXXZasn3HGGcl6pVJpWLviiiuSy0pK1q0z3vObZcrhN8uUw2+WKYffLFMOv1mmHH6zTDn8Zpnycf493DHHHJOs33777cn6pZdemqzfeeedbdfffffd5LIXX3xxsj48PJysW5r3/GaZcvjNMuXwm2XK4TfLlMNvlimH3yxTDr9ZpnycP3PnnXdesn7ssccm60uWLEnWU9/7/41vfCO57EsvvZSsX3PNNcn6tGnTkvXcNd3zS7pN0nZJm+qmLZf0qqQNxe1LvW3TzLqtlZf9twNnjTP9hoiYVdzu625bZtZrTcMfEY8BO/rQi5n1UScf+F0paWPxtuDwRjNJWiSpKqk6OjrawerMrJvaDf+PgWOAWcBW4HuNZoyIlRFRiYjK0NBQm6szs25rK/wRsS0idkbER8AtwKndbcvMeq2t8Euqv5byPGBTo3nNbDA1Pc4vaTUwF5gqaQtwLTBX0iwggBHg8h72aCU68cQTk/U1a9Yk6/fee2/D2iWXXJJc9uabb07Wn3/++WT9wQcfTNZz1zT8EbFgnMk/6UEvZtZHPr3XLFMOv1mmHH6zTDn8Zply+M0ypYjo28oqlUpUq9W+rc8G23777Zesf/DBB8n6Pvvsk6zff//9DWtz585NLjtRVSoVqtVqS2Obe89vlimH3yxTDr9Zphx+s0w5/GaZcvjNMuXwm2XKX91tSRs3bkzW165dm6yvX7++Ya3ZcfxmZs6cmayfdtppHT3/ns57frNMOfxmmXL4zTLl8JtlyuE3y5TDb5Yph98sUz7Ov4fbvHlzsv6jH/0oWb/rrruS9d/85je73VOr9t47/ec5PDycrO+1l/dtKd46Zply+M0y5fCbZcrhN8uUw2+WKYffLFMOv1mmWhmiezpwJ/BJ4CNgZUT8UNIU4J+BGdSG6f5KRPyud63mq9mx9FWrVjWsrVixIrnsyMhIOy11xSmnnJKsX3PNNcn6ueee2812stPKnv9DYElE/DHwJ8AVkmYCy4CHI+I44OHiZzObIJqGPyK2RsQvi8dvA88B04B5wB3FbHcA83vVpJl1326955c0AzgJeBI4MiK2Qu0fBHBEt5szs95pOfySDgJ+DnwtIt7ajeUWSapKqo6OjrbTo5n1QEvhl7QPteD/NCLGrvTYJmm4qA8D28dbNiJWRkQlIipDQ0Pd6NnMuqBp+CUJ+AnwXER8v650D7CweLwQuLv77ZlZr7RySe8c4CLgGUkbimlXA9cBayR9FXgZOL83LU5827ZtS9afffbZZP3KK69M1n/1q1/tdk/dMnv27GT961//esPavHnzksv6ktzeahr+iHgcaDTe9+e7246Z9Yv/tZplyuE3y5TDb5Yph98sUw6/WaYcfrNM+au7W7Rjx46Gtcsvvzy57IYNG5L1F154oa2eumHOnDnJ+pIlS5L1L37xi8n6AQccsNs9WX94z2+WKYffLFMOv1mmHH6zTDn8Zply+M0y5fCbZSqb4/xPPvlksn799dcn6+vXr29Y27JlS1s9dcuBBx7YsLZ48eLkss2+Hnvy5Mlt9WSDz3t+s0w5/GaZcvjNMuXwm2XK4TfLlMNvlimH3yxT2RznX7duXUf1TsycOTNZP+ecc5L1SZMmJetLly5tWDvssMOSy1q+vOc3y5TDb5Yph98sUw6/WaYcfrNMOfxmmXL4zTKliEjPIE0H7gQ+CXwErIyIH0paDlwGjBazXh0R96Weq1KpRLVa7bhpMxtfpVKhWq2qlXlbOcnnQ2BJRPxS0sHAU5IeLGo3RMR3223UzMrTNPwRsRXYWjx+W9JzwLReN2ZmvbVb7/klzQBOAsa+E+tKSRsl3Sbp8AbLLJJUlVQdHR0dbxYzK0HL4Zd0EPBz4GsR8RbwY+AYYBa1VwbfG2+5iFgZEZWIqAwNDXWhZTPrhpbCL2kfasH/aUTcBRAR2yJiZ0R8BNwCnNq7Ns2s25qGX5KAnwDPRcT366YP1812HrCp++2ZWa+08mn/HOAi4BlJY2NNXw0skDQLCGAESI9TbWYDpZVP+x8HxjtumDymb2aDzWf4mWXK4TfLlMNvlimH3yxTDr9Zphx+s0w5/GaZcvjNMuXwm2XK4TfLlMNvlimH3yxTDr9Zphx+s0w1/erurq5MGgVeqps0FXi9bw3snkHtbVD7AvfWrm72dnREtPR9eX0N/8dWLlUjolJaAwmD2tug9gXurV1l9eaX/WaZcvjNMlV2+FeWvP6UQe1tUPsC99auUnor9T2/mZWn7D2/mZXE4TfLVCnhl3SWpM2Sfi1pWRk9NCJpRNIzkjZIKnU88WIMxO2SNtVNmyLpQUnPF/fjjpFYUm/LJb1abLsNkr5UUm/TJT0i6TlJz0r6m2J6qdsu0Vcp263v7/klTQL+C/hzYAuwHlgQEf/Z10YakDQCVCKi9BNCJJ0GvAPcGREnFNOuB3ZExHXFP87DI+JvB6S35cA7ZQ/bXowmNVw/rDwwH7iEErddoq+vUMJ2K2PPfyrw64h4MSLeB34GzCuhj4EXEY8BO3aZPA+4o3h8B7U/nr5r0NtAiIitEfHL4vHbwNiw8qVuu0RfpSgj/NOAV+p+3kKJG2AcATwg6SlJi8puZhxHRsRWqP0xAUeU3M+umg7b3k+7DCs/MNuuneHuu62M8I839NcgHW+cExEnA2cDVxQvb601LQ3b3i/jDCs/ENod7r7bygj/FmB63c+fAl4roY9xRcRrxf12YB2DN/T4trERkov77SX383uDNGz7eMPKMwDbbpCGuy8j/OuB4yR9WtK+wAXAPSX08TGSJhcfxCBpMnAmgzf0+D3AwuLxQuDuEnv5A4MybHujYeUpedsN2nD3pZzhVxzK+AEwCbgtIr7d9ybGIekz1Pb2UBvBeFWZvUlaDcyldsnnNuBa4F+BNcAfAS8D50dE3z94a9DbXGovXX8/bPvYe+w+9/ZnwL8BzwAfFZOvpvb+urRtl+hrASVsN5/ea5Ypn+FnlimH3yxTDr9Zphx+s0w5/GaZcvjNMuXwm2Xq/wHFoUPrAn/lWgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11eec4630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣\n",
      "5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n"
     ]
    }
   ],
   "source": [
    "mnist_data = extract_data(10, 10)\n",
    "beach, digits = create_mnist_beach()\n",
    "\n",
    "def show_example(beach, digits, index):\n",
    "    item = mnist_data.train.get_item(index)\n",
    "    show_image(item.image, item.label)\n",
    "    digit = digits[item.label]\n",
    "    beach.animate(item.where + digit, iterations=0, show=True)\n",
    "    beach.night(show=False)\n",
    "\n",
    "show_example(beach, digits, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training examples: 500\n",
      "  100% [=================================================================] Time elapsed: 336.67s\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# extract train and test datasets\n",
    "mnist_data = extract_data(500, 250)\n",
    "\n",
    "# create beach\n",
    "beach, digits = create_mnist_beach()\n",
    "\n",
    "# train the network\n",
    "dataset = mnist_data.train\n",
    "print(f\"Training examples: {dataset.size}\")\n",
    "pb = ProgressBar(dataset.size)\n",
    "time_start = time.time()\n",
    "for index in range(0, dataset.size):\n",
    "    item = dataset.get_item(index)\n",
    "    digit = digits[item.label]\n",
    "    beach.animate(item.where + digit, iterations=10, show=False)\n",
    "    beach.night(show=False)\n",
    "    pb += 1\n",
    "time_elapsed = time.time() - time_start\n",
    "print(f\" Time elapsed: {time_elapsed:.2f}s\")\n",
    "del pb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we create and attach the listeners. We create a listener for each digit, the listeners share the class variable `winner` that will store the prediction given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DigitListener():\n",
    "\n",
    "    threshold = 50\n",
    "    winner = None\n",
    "\n",
    "    def __init__(self, digit):\n",
    "        self.digit = digit\n",
    "        self.threshold = DigitListener.threshold\n",
    "\n",
    "    def reset(self):\n",
    "        DigitListener.winner = None\n",
    "        self.threshold = DigitListener.threshold\n",
    "\n",
    "    def fire(self, octopus):\n",
    "        if octopus.awake:\n",
    "            self.threshold -= 1\n",
    "        if (self.threshold == 0):\n",
    "            if DigitListener.winner == None:\n",
    "                DigitListener.winner = self.digit\n",
    "            self.threshold = DigitListener.threshold\n",
    "\n",
    "for i, digit in enumerate(digits):\n",
    "    beach.attach_listener(digit, DigitListener(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction\n",
    "\n",
    "The function `predict` animate the beach with the features corresponding to a test digit and then it sees which digit is stored in the class variable `DigitListener.winner`, that is the prediction given by the octopusal network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(index, dataset, show=False):\n",
    "    item = dataset.get_item(index)\n",
    "    label = item.label\n",
    "    if show: show_image(item.image, item.label)\n",
    "    beach.animate(item.where, iterations=10, show=show, freeze_connections=True)\n",
    "    winner = DigitListener.winner\n",
    "    beach.night()\n",
    "    return winner == label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next example we get a correct prediction. You can see how at the sixth iteration the group of octopuses in charge to recognize the digit zero wake up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x123a384e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\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",
      "Iteration 1 - smell: 111\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",
      "Iteration 2 - smell: 111\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",
      "Iteration 3 - smell: 111\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",
      "Iteration 4 - smell: 111\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",
      "Iteration 5 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 6 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 7 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 8 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 9 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 10 - smell: 161\n",
      "\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙💡🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡🐙🐙💡🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙\n",
      "💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙\n",
      "🐙💡🐙🐙💡💡💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡💡🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙💡💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙\n",
      "🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "💡🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡💡🐙🐙💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣\n",
      "0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣0️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n"
     ]
    }
   ],
   "source": [
    "correct = predict(1, mnist_data.train, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next example we get a wrong prediction. You can see how at the sixth iteration the group of octopuses in charge to recognize the digit three wakes up but the correct digit is five. At iteration 7 wakes up also the group corresponding to the 5 but it's late because the prediction given is the first one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x123977a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\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",
      "Iteration 1 - smell: 116\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",
      "Iteration 2 - smell: 116\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",
      "Iteration 3 - smell: 116\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",
      "Iteration 4 - smell: 116\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",
      "Iteration 5 - smell: 116\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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 6 - smell: 166\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 7 - smell: 200\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣\n",
      "5️⃣5️⃣5️⃣5️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 8 - smell: 200\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣\n",
      "5️⃣5️⃣5️⃣5️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 9 - smell: 200\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣\n",
      "5️⃣5️⃣5️⃣5️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n",
      "Iteration 10 - smell: 200\n",
      "\n",
      "🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙💡🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙\n",
      "🐙🐙💡💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙🐙💡💡🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡💡🐙💡🐙🐙💡🐙💡🐙🐙\n",
      "🐙🐙🐙🐙💡🐙💡🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙\n",
      "🐙🐙🐙💡💡💡🐙🐙💡🐙🐙🐙🐙🐙🐙🐙💡🐙💡🐙🐙💡💡🐙🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙💡🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙\n",
      "💡🐙💡🐙🐙🐙💡🐙🐙💡💡💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡💡\n",
      "🐙💡🐙🐙💡💡🐙🐙💡🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙💡🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡\n",
      "🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙🐙🐙🐙🐙🐙💡🐙🐙🐙💡🐙💡💡🐙🐙🐙🐙💡💡🐙💡🐙🐙🐙🐙💡💡🐙🐙\n",
      "🐙🐙🐙🐙🐙💡💡💡🐙🐙🐙💡🐙💡💡💡\n",
      "🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗🔗\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣3️⃣\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣5️⃣\n",
      "5️⃣5️⃣5️⃣5️⃣🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙🐙\n",
      "\n"
     ]
    }
   ],
   "source": [
    "correct = predict(0, mnist_data.train, show=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last cell we iterate over 250 test digits and calculate how many predictions are correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test samples: 250\n",
      "\n",
      "  100% [=================================================================] Time elapsed: 183.35s\n",
      "\n",
      "Correct: 86.40%\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from progress_bar import ProgressBar\n",
    "\n",
    "correct = 0\n",
    "\n",
    "start = 0\n",
    "count = 250\n",
    "\n",
    "print(f\"Test samples: {count}\\n\")\n",
    "\n",
    "pb = ProgressBar(count)\n",
    "time_start = time.time()\n",
    "\n",
    "for i in range(start, start + count):\n",
    "    result = predict(i, mnist_data.test, show=False)\n",
    "    if result == True:\n",
    "        correct += 1\n",
    "    pb += 1\n",
    "\n",
    "time_elapsed = time.time() - time_start\n",
    "print(f\" Time elapsed: {time_elapsed:.2f}s\")\n",
    "del pb\n",
    "\n",
    "print(f\"Correct: {correct / count * 100:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions\n",
    "\n",
    "I don't know if the use of the convolutional base has the greater part of the merit but I think that it's quite a good result anyway. The algorithm is still not optimized but seems to me that it has good perception skills. In addition to perception it has also other qualities as seen in the [previous notebook](https://nbviewer.jupyter.org/github/marconunnari/octopusal_networks/blob/master/OctopusalNetworks.ipynb).\n",
    "\n",
    "In the [next notebook](https://nbviewer.jupyter.org/github/marconunnari/octopusal_networks/blob/master/MnistVectorized.ipynb) using vectorization we get a far better and faster result on the MNIST."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: right\"><i>Marco Nunnari<br>May 2018</i></p>"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}