{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several years ago I was waiting for <a href=https://en.wikipedia.org/wiki/Great_Fountain_Geyser>Great Fountain Geyser</a> in Yellowstone to erupt. We ended up needing to wait several hours for the eruption (but boy was it worth it, earning Great Fountain a status as my favorite geyser in Yellowstone). \n",
    "\n",
    "Around 45 minutes in to the wait a group of people came to sit behind us and soon after I overheard one of them tell a riddle that kept my mind happily occupied for both the next several hours until the eruption. The riddle as I originally overheard it went something like this,\n",
    "\n",
    "> 100 prisoners are given the following deal: Each day one of them will be selected at random and taken to a room with a single light bulb. That prisoner will be given the option to turn the light on or off and will then be asked if they are certain that all the other 100 prisoners have been in the room. If they answer yes and are correct then all the prisoners will be set free, If they are incorrect then all the prisoners will be executed.\n",
    "The prisoners are allowed to discuss their strategy prior to the beginning of this process but once one of them is taken into the room all communication between the prisoners will be cut off. \n",
    ">\n",
    "> What strategy should they agree upon?\n",
    "\n",
    "<!-- END_TEASER -->\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The \"Show Your Work\" Version\n",
    "\n",
    "As stated above a perfectly good strategy is to just wait N days and then say yes no matter what. It turns out that in less than 2 years all the prisoners will most likely have been in the room at least once and it is a near certainty by 5 years time. \n",
    "\n",
    "But this solution sort of misses the whole point of the puzzle in my opinion. The real question is how can the prisoners use the lightbulb to effectively communicate whether or not they have been in the room? A tongue in cheek modification of the riddle that eliminates this as a strategy (and removes the somewhat morally problematic 'prisoner' riddle style) might go something like this,\n",
    "\n",
    "\n",
    "> 100 mathematics professors are given the following deal: Each day one of them will be selected at random and taken to a room with a single light bulb. They will be given the option to turn the light on or off and will then be asked if they can prove from their sequence of observed lightbulb states and agreed upon strategy that all the others have been in the room (assuming perfect adherence to the strategy).\n",
    ">\n",
    "> What strategy minimizes the expected number of days required to make a valid proof?\n",
    "\n",
    "Being mathematicians, they of course don't need any punishment or reward associated in order to happily theorize about various possible strategies and maybe even write papers putting upper or lower bounds on the expected number of days it takes for the process to complete for various kinds of strategies. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Simple Asymmetric Solution (Spoilers)\n",
    "\n",
    "It took me quite a number of hours over several days of camping to think up a solution to this problem. But a big reason for what took me so long was that early on I had commited to the idea that I wanted every prisoner to behave in the same way as all the others. I reasoned that since the space of possible such \"symmetric\" strategies is much smaller than the possible set of \"asymmetric\" strategies in which the prisoners could be assigned special roles surely it would be easier to reason about. Furthermore, I reasoned that even if I found a good asymmetric solution in which only a single member of the group was receiving information surely that could not be the \"fastest possible\" strategy since that special member would be someting of an information bottle neck.\n",
    "\n",
    "I did eventually come up with such a symmetric strategy in which all the prisoners behave in the same way as each other (which we will talk much more of later). For years this was the only solution to the riddle that I was aware of and I sort of assumed that my solution was close to as simple as possible.  But it turns out that I was wrong in thinking that the symmetric strategies would be simpler just because there were fewer of them.\n",
    " \n",
    "If you haven't already thought up a solution to this riddle and would like to give it a try with this one additional hint that assigning special roles to the prisoners may be a good idea, here is your last chance to look away for a bit and give it some thought.\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "This space intentionally left blank\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "This space also intentionally left blank\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Last Chance\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"easy\" way to achieve certainty is to just count up to 100. You assign a single special member of the group to be the \"counter\" and they turn the light off if it is on. Every other member of the group turns the light on exactly once if they are brought into the room to find that it is currently off. Once the counter has turned the light off 99 times they know that everyone else must have had the opportunity to turn the light on at least once.\n",
    "\n",
    "Tada!\n",
    "\n",
    "## How long does it take?\n",
    " \n",
    "Although this solution definitely works. How long does it take to carry out? As a quick order of magnitude estimate we just need to know around how long will it take for the counter to be selected N-1 times. Most of the time someone other than the counter will have left the light on for the counter (although once there is just one person left to count the probability will drop down to as 50%). Ignoring the chance that the counter might come in twice in a row without any other intervening candidates who can leave the light on that gives an estimate of N*(N-1) days on average. With the miss rate caused by the light failing to be turned on the real duration should be just a little over this.\n",
    "\n",
    "This is born out by simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.ndimage.filters\n",
    "import random\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams.update({\n",
    "    \"figure.figsize\":(12, 6),\n",
    "    \"font.size\":18,\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_count_strategy(\n",
    "    N_members, \n",
    "    max_days=150000,\n",
    "):\n",
    "    light_state = False\n",
    "    count = 0\n",
    "    has_turned_on = np.zeros(N_members, dtype=int)\n",
    "    light_history = []\n",
    "    member_history = []\n",
    "    \n",
    "    for i in range(max_days):\n",
    "        ci = np.random.randint(N_members)\n",
    "        if ci == 0: #the counter/aggregator was selected\n",
    "            if light_state:\n",
    "                count += 1\n",
    "            light_state=False\n",
    "        else:\n",
    "            if (not light_state) and has_turned_on[ci] == 0:\n",
    "                has_turned_on[ci] = 1\n",
    "                light_state = True\n",
    "                \n",
    "        light_history.append(light_state)\n",
    "        member_history.append(ci)\n",
    "        \n",
    "        if count >= N_members - 1:\n",
    "            break\n",
    "    \n",
    "    return np.array(light_history), np.array(member_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_days_count_strat = []\n",
    "count_rates = []\n",
    "\n",
    "for sim_index in range(1000):\n",
    "    light_states, member_indexes = simulate_count_strategy(100)\n",
    "    n_days_count_strat.append(len(light_states))\n",
    "    #fraction of the time the counter finds the light on.\n",
    "    count_rate = np.mean(light_states[np.where(member_indexes==0)[0]-1])\n",
    "    count_rates.append(count_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10411.43"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(n_days_count_strat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9508361542935407"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(count_rates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_entropy(p):\n",
    "    return -1.0*(p*np.log2(p) + (1-p)*np.log2(1-p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.28283436020404523"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_entropy(np.mean(count_rates))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(n_days_count_strat, 21);\n",
    "plt.title(\"Duration of 'Counting' Strategy\", fontsize=18);\n",
    "plt.xlabel(\"Number of Days\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mean number of days required by the counting strategy clocks in at just around $N^2$ which is what you would expect from the above back of the envelope calculation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Lightbulb Channel Bit Rate\n",
    "\n",
    "Now to ask a question that is close to where I started my thought process.\n",
    "\n",
    "What is the information theoretic limit to how much information we can pass per day using this lightbulb?\n",
    "\n",
    "Clearly since the lightbulb itself has just 2 possible states we can use it to transmit no more than $log_2(2)=1$ bit per day. But there is an extremely odd sort of \"noise\" process at work here which is heavily limiting our communication ability and so the real achievable channel capacity must be somewhere below this.\n",
    "\n",
    "The nature of the communication channel is so odd that I still can't really see any better way to reason about what the channel capacity is other than to just estimate it for particular strategies.\n",
    "\n",
    "For the above strategy it takes around 100 days each time to transmit an \"on\" signal from one of the rank and file group members to the counter and it takes 99 such transmissions to count up to the required 100. If you are generous then you may suppose that each of these messages transmits one bit worth of information in which case the bit rate of the channel is around 1/100 bits per day. In reality each of these messages certainly carries less than a full bit of information since the light bulb will almost always be in the \"on\" state when the counter comes into the room. A more accurate estimate would be that each \"on\" signal transmits a number of bits close to the entropy of the probability of an \"on\" signal as received by the counter. In the above simulations the counter found the lights on 95% of the time which is a binary entropy of around 0.3 bits. All together that gives a channel capacity estimate of 0.003 bits/day.\n",
    "\n",
    "That is a depressingly low capacity communication channel!\n",
    "\n",
    "Is there perhaps a more high bandwidth way to communicate that could get us closer to the physical limitation of 1 bit/day worth of information communicated?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Message Passing\" Type Solutions\n",
    "\n",
    "As I mentioned above I originally was hunting for a solution in which there are no special roles for the members. In the above counting strategy we are always sending the same message \"increment by 1\". But what if we instead sent a different message where the meaning of the message differs by the day? The participants can agree ahead of time what an \"on\" signal should mean on any given day. This removes one factor of 100 from the denominator in the above bit rate calculation. Since every participant can be both a sender and a receiver of messages the chances that the message is sent and received the next day can be as high as we like (though we will not know who is receiving each message). \n",
    "\n",
    "What sort of logical messages could the participants send to each other such that they would be guaranteed to eventually be able to show that they had all been in the room?\n",
    "\n",
    "Since I set the precedent above of putting a little spacer out front of the solution to the problem here it is again. If you want to take a while and think this through now is the time. One point of clarification first though, when I say that there are no special roles for the prisoners that does not mean that there isn't special information available to each prisoner, for example each prisoner knows their own assigned number. When I say that all prisoners act the same I mean they all turn the light on/off according to the same set of rules given the information available to each of them. You may well come up with a totally different solution than I did and if you do please put it in the comments for this post.\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "This space intentionally left blank\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "This space also intentionally left blank\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Last Chance\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mod N Message Passing\n",
    "\n",
    "The solution I came up while camping in Yellowstone was this,\n",
    "\n",
    "Leave the light on for day D if you know that participant k has been in the room and k = D mod N.\n",
    "\n",
    "So for example suppose that we have just N=3 participants instead of 100. \n",
    "\n",
    "A particularly unlucky sequence would be \n",
    "\n",
    "1,2,3,1,2,3,1,2,3,1,2,3,...etc\n",
    "\n",
    "Initially each participant can only know whether or not they themselves have been in the room. So until they come into the room to find the light on and therefore can expand their set of known participants they can only leave the light on when they happen to come in to the room on a day which is one less than their assigned number mod 3. Since this never happens in the above sequence the light always stays off and no information is passed around.\n",
    "\n",
    "In contrast particularly lucky sequence of participants to send into the room would be\n",
    "\n",
    "2,3,1,3,1\n",
    "\n",
    "The corresponding sequences of light states would be \n",
    "\n",
    "* day 1 light-\"off\" (initial state -> no message being sent) p2 comes in and they leave the light on because tomorrow is day 2 and they know they themselves have been in the room. \n",
    "* day 2 light-\"on\"  p3 comes in sees the light on and now knows p2 has been in the room. They also leave the light on because tomorrow is day 3 and they know they themselves have been in the room. \n",
    "* day 3 light-\"on\"  p1 comes in sees the light on and now knows that p3 has been in the room. They also leave the light on because tomorrow is day 4 which is 1 mod 3 and they know they themselves have been in the room. \n",
    "* day 4 light-\"on\" p3 comes in sees the light on and now knows that p1 has been in the room. They leave the light on because tomorrow is day 5 and 5 is congruent to 2 mod 3. On day 2 they came into the room to see the light on and so they know that p2 has been in the room.\n",
    "* day 5 light-\"on\" p1 comes in and sees the light on and so they now know that both 2 and 3 have been in the room because of the messages they received on day 5 and day 3 respectively. \n",
    "\n",
    "Participant 1 will then announce that everyone must have been in the room and everyone can go to the pub to celebrate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How Fast is the Mod N Solution?\n",
    "\n",
    "When I first thought of this solution I thought it must be just about as fast as you could get. Every time the light gets left on it increases the probability that it will get left on again, and unlike any sort of asymmetric solution with different roles all 100 participants can trigger the end state of the game and so it must be faster than such asymmetric solutions right?\n",
    "\n",
    "Using a similar sort of logic as the back of the envelope calculations up above you would suppose that you transmit initially around 1/N messages per day and it will take N such messages to be accumulated by any given participant in order to end the game which means that it will take on order $\\mathcal{O}(N^2)$ days for the information to completely percolate. But the factor out front of that $N^2$ is harder to estimate than in the case of the counting solution. \n",
    "\n",
    "While I was camping in Yellowstone I didn't have a computer available to do any simulations and I would have guessed that the factor out front of $N^2$ would be small, perhaps 1.x or something of that nature. \n",
    "\n",
    "I sort of forgot about this puzzle until more than a year later when I was talking to a friend of mine who knew of this particular riddle and they told me about the counting solution I already mentioned. I was sort of surprised that I had overlooked such a simple straightforward solution in favor of the arguably much more complicated message passing solution I have described. \n",
    "\n",
    "But surely my more \"sophisticated\" symmetric role solution was faster right? \n",
    "\n",
    "Lets do some simulations and find out.\n",
    "\n",
    "It is hard for me to think of a more general sort of message we may want to send other than \"The sender knows that all of the participants in the set {...} have been in the room\". The mod N strategy above certainly falls into this class of message. Lets offload the crafting of the messages into a function we pass into the simulation function so that we can also explore more general message passing solutions later if we like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_message_strategy(\n",
    "    N_members, \n",
    "    message_fn,\n",
    "    max_days=150000,\n",
    "):\n",
    "    light_state = False\n",
    "    knowledge_sets = [set() for i in range(N_members)]\n",
    "    \n",
    "    light_history = []\n",
    "    member_history = []\n",
    "    n_known_history = []\n",
    "    \n",
    "    implied_indexes = []\n",
    "    \n",
    "    for day_idx in range(max_days):\n",
    "        ci = int(np.random.randint(N_members))\n",
    "        c_know = knowledge_sets[ci]\n",
    "        c_know.add(ci) #we know have been in the room regardless of the light state\n",
    "        \n",
    "        if light_state:\n",
    "            #if the light was on someone has sent us a message\n",
    "            #lets add it to our known set\n",
    "            for idx in implied_indexes:\n",
    "                c_know.add(idx)\n",
    "        \n",
    "        #calculate tomorrows message and see if we know enough to transmit\n",
    "        implied_indexes = message_fn(day_idx+1, N_members)\n",
    "        \n",
    "        know_all = all([idx in c_know for idx in implied_indexes])\n",
    "        light_state = know_all\n",
    "                \n",
    "        light_history.append(light_state)\n",
    "        member_history.append(ci)\n",
    "        n_known_history.append([len(kset) for kset in knowledge_sets])\n",
    "        \n",
    "        if len(knowledge_sets[ci]) == N_members:\n",
    "            break\n",
    "    \n",
    "    return np.array(light_history), np.array(member_history), np.array(n_known_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modN_message_fn(day_idx, N):\n",
    "    return [day_idx % N] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_days_modn_strat = []\n",
    "light_on_fractions = []\n",
    "\n",
    "for sim_index in range(100):\n",
    "    light_states, member_indexes, known_counts = simulate_message_strategy(\n",
    "        100,\n",
    "        message_fn=modN_message_fn,\n",
    "    )\n",
    "    #light_states, member_indexes = simulate_modn_strategy(100, max_days=120000)\n",
    "    n_days_modn_strat.append(len(light_states))\n",
    "    #fraction of the time the light is on\n",
    "    light_on_fractions.append(np.mean(light_states))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "91927.05"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(n_days_modn_strat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAGXCAYAAADyEeXtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAugklEQVR4nO3deZhsRX3/8fcHr+wKKjdGMXAlKhqjUUNQ44b7wi9q3KIGIm7EuCXEDZdE4or7vuTiguAGGCUqGoUoiqIiKAoaRZbrLoKCsorA9/dHnZGm6Zk7M7f7zPTM+/U85+nbdaqrqk/1ufPt6jp1UlVIkiRJ6sdmS90ASZIkaTUxAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JJ6kWSfJJVkj6Vuy3wl2SHJIUl+1rX92KVu03KQZIPHQpIWzwBcWsaS7NEFfjPbFUnOS3JqkvcleUCSLHU7Z3TtPSDJ9kvdljF5HfB3wDuBvYGXz5Yxybquj/YZsW9NkickOTrJOUkuS/KrJJ9P8owkW0/sHSxS148PXep2AHTH9YB55t0lyfok30tycXe+fLc7X+45lHfi7zHJ7bp61k2yHknTZc1SN0DSvHwI+BQQ4DrArsBDgX8AjknyyKo6f8lad5U9gBcDBwPnD+07FPgwcFmvLdo09wU+U1UvWWwBSdYCHwfuBHwNeCPwc2B74O7AG4C7AY/axLaO24uB9wFHjti3K7Ds7uKWZDfgC8DvgUOA7wBbAbcA/ga4APj8wEvmeo/jcruunmOBDROsR9IUMQCXpsM3qur9gwlJ/hV4NfCvtAD9geOsMMl1quqCcZVXVVcAV4yrvJ78MfDrxb64+3XiI7Tg+5lV9ZahLK9PcgvgEYtvYv+q6ndL3YZZvBjYGrh9VZ08uCPJ02n9uWjjPickrV5OQZGmVFVdUVXPAr4EPCDJXWf2JTk4ycgRyu7n/IMHns9MnTggyd8lOSnJJcBbuv23TPL2JN9JckH3s/5JSZ48VO7BtAAI4KyBaTMHdPtHzgHv5lm/LcmPu6kZP+6e32Ao38zr75Xk2UnOSPK7JKcledx8j1uSbZK8cuD1v+jmee88kOeA7vgFeNzAe9lnvvV0/h9tlPuwEcE3AFV1WlW9YqiNd++mq/wmySVJvpHkiSPey8i52ANTl/YZSJvX8Zv5PHRPB997DeS5Rr0zad3n5ajus/KbJB9Jco3AN8ltk3w2yUXddJz3dZ+Fq30+F+jmwK+Gg2+Aqrqyqn62gPdY3Xl07yRfSnIh8Ilu342TvC7JyWlTXC5Nm+byvCTXGijjAOC93dPPD9Rz8ECeLZK8oDu/Lk1yfpJPJLn9iGN2gyTv6Y7XhUk+l+T23XHfMJDvW0l+lOQaf+OTPKprw94LOK6SxswRcGn6vRu4K7AnLRhfrIcCzwTeQZvz/NsufQ9aEPlJ4CxgG+CRwPokO1TVK7t8/wlcF/hbYD/g3C7927NVmGQ74HjgZsB7gG8Atwf+CbhXkt1HjDi+gjat4D+B33V5D05yelV9ea43mGQN8BngLrSR6dfRgrZ/Au6XZLeq+gnwUeB02rSZ44D1XRHHz1X+CDMj2+vnzHX1Nv4N8DHgF137LgAeDbwryS5V9cIFtmHYxo7fObT57sPvfT52pE21+BjwHOAvgH+kfS7uN5Mpyc27sjcD3gz8FHgQ8OlNeF8AZwC7JnlYVX10jnzzfY+7AQ8HDqJNVZlxW+BhtPd5BnBt2i9QBwK70N4ztM/RjYB9acf9/wbaSZJrA/8D/HXXlrcC2wFPBr6c5O5VdWKXd3PgGNqUloOBE7p2HMM1f6U5iPYF+r60z/ugJwC/oX3+JS2VqnJzc1umGy34LeDZc+S5Q5fnvwbSDm6n98j8BRw88Hxdl/Z74FYj8m8zIm0zWqD1G+DaA+kHdGWtG/Gafbp9ewykvbxLe+pQ3qd16S8d8fpvApsPpO9ICyQ/NI/j+eSujFcPpe/ZpR8617FaRP+d1JVx/XnmvxbwQ9r8+RsPpG8OfJk2hefmA+kbgGPn+Nzss9jjN9d7H1Vvl1bAo4bS39al33Ig7fAu7S5DeQ/blGMO3Jl2jUEBp9G+1P3TqM/1PN5jddt9RuzbCsiI9EO7PrrRXJ/7gX37dfvuP5R+XeBHg8cYeGqX94VDeWfSNwykbQdcBBw+lPdPuva9fbGfaTc3t/FsTkGRpt/MSPV1N7Gco6rq/4YTq+qimX8n2bKbGnJ94LNdnbfchDr/ljYaOTwC+Z+0EfS/HfGat1fVHy7krKqf0oKtm8+zviuBVw4mVtVRwMnAQ0b9bL8JZvrkt3PmuspfAjsB76luukTXvsuA19C++DxkE9u0KcdvY35WVYcPpX2ue7wZQDdF40HACXXNXyxetymVV9VXaMfwfbQg9PHA24HvJjkuyS4LLPJbVXXMiHouqaqCNjKd5PpJdqCNNm9GGzmfj72A7wEnddNvdujK2Rw4Grhrkq26vH9DC57fNFTGQbQvwoPt+w1wBO3zvMPArsd37Xv3PNsnaUIMwKXpt9AgbzanjUpMsm2S1yb5EXAJLTA+h6uW5LveJtR5U+D7VXX5YGL3/Pu0n/OHnTki7VfADUakj6rvZ1V13oh936GtMLPDiH2LNdMn15ln/psOtGXYqd3jQoPIYZty/BZbNgPlr6VNY/r+iLyj0hakqk6pqn2q6oa0X3ceR5tmclfgv7upHPM12zmxJsmLkpwGXEp7j+fQRsBh/ufErWhfYM8ZsT2B9ovIzOdx5rN74WABVfV72tSwYetpgfxeXZtDC8BPrqqT5tk+SRPiHHBp+t22exwMXma7AHOuc/7iWdI/SLuYcD3wRdp808tpo5j70f8X+dlWUpnPeuh9r5l+Km2K0O25aiR4Lgtt32xLAc7Vz5ty/DZmrlVuMvQ4yliXNqyqHwKHJJmZ630XYHfmf63EbOfE64Fn0KbMvBz4JW0K1x2AVzH/cyLAKbSVjGZzzkDeeauq45OcCjyRtvTlvWlfSJ6+kHIkTYYBuDT9ZlbHOGog7dcASa5fVYMXaC1o9DTthjr/jzY3+ilD++4z4iULDaDOpF00t2ZwFLz7onALRo+oboozaCvGbF/XXDf9z2gj1ude41WL91+0tdqfxPwC8DO6x1uP2Pdn3ePgMfk1bTrQsE0dJZ+kX9LmJ+86Yt+mTGeaVVVVkq/RAvAdx1Dk3sAXq+rRg4lJbjaq+jnK+QHtF4HPVdWVG6nzLOA+SbYdHAXvLuS8Kddcdx/a9JQ3Jdmd9v/EpcAHNlKPpB44BUWaUkmuleS1tJ/WPzU0n3bmp/PhIPlZC6xmZkTzaqNvSW5ECyqHzQQGo4LCUY6kBSDDZT25S//YPMuZryNp/+/tP5iY5IG0UeqPzyMQWohP0H41eEySp47KkORmSZ7fPf0G7eK7xw8u3dcFWc+hBXP/PfDy04BbJtlxIO8WtItYN9WFzL8f563aevCfBnZPcpeh3Qv9fF5NkvuO+pWnm0c9swrLdwd2LfY9XsE1z4ltaL8IDZvrnDiEtjb5yBHwJDccePoJ2pSUfx7K9mTafPdRDqUF3c+hXf/wXyO+eEpaAo6AS9PhDkn26v49eCfMnWkXQz52KP+HaMuerU9yS9oc1QeywPnNVXVBks8Ce6WtDf71rs5/pI3IDc8b/mr3+KokH6D98T+1qk5ltFfTljR8W5I70FbouD1ttO773f5xOpg2J/h5abcG/yLt4sCnAmcDLxhnZd3I6yNowdPburWXP05bYnB72penB9NGyqmqK9JuGPMx4OtJ1tOWIfw72s18XlFVPxio4q20JQqPSfJO2pzfvZl96sRCfJU24vo82peCqqoPj6FcgBcB9wf+J8lbgZ/QVqJZ2+1f7FSUNwA3SPJx2tSOi2krfzyW9ovKIVV1ykD+xb7HjwD/mOQw2jKAN6TN2f7ViLxfp134+8Ik16ON/p9VVV+jXVB5X+A1Se5F+5Xkt7QLce9NO3/u2ZXzLtp597JupH1mGcJH0ZbMvMbf86o6L8lH6OaBd2VIWg6WehkWNze32TeuWk5uZruCtuLBd2grPTxgjtfekbZ03aW0aRXraUHfbMsQHjBLOTvQ/nD/rCvrFNqo2z6MWF4NeC5tmsTvB8udI/9a2koVP+le8xPa0nU7DOUb+fpu37EMLMO2kWO6DW0VlDNpS9b9kjZSuPOIvJu0DOFAOdemfak4puuL39OCtc/Rgv+thvLfg7YKxm+7Y/5N4EmzlP042peVy2hfip4L3IvZlyGc1/GjrYry2a4NxcCylsy+DOGxI8reY7gtXfrtuuNxMW0qzSG0qRTFIpfJo41yvw34VnecL++O8+dpAfJmC3iPcy1RuDVtVZofdv3zA9qvKvee5b0+jjbyftlwubTA+Zm0QP2ibvsBbarI/UacKwd3x+ui7vNzO+BE4LuztPVuXZ0/YMTSiW5ubkuzpWqs17xIkrQoSf6SFkw+v6oOXOr2TINuWcdzga9V1QNG7N8d+BrwgrrqplmSlphzwCVJvRtY33rmeWij99BG/zVk+Jh1nkL7ZWu2Y/Z02i8u751QsyQtgnPAJUlL4eQkn6NNadqGdqOZuwGHletUz+agJFsCx9PuXnpn2vz20xm4mVV3Qejf0FbT2QtYX1W/6L+5kmbjFBRJUu+SvJoWJP4JbTDoLNq851dVu7mMhiT5B9oKN7cAtqVdOPwp4N+q6uyBfOtox/NC2oozT6qqTb1Rl6QxMgCXJEmSeuQccEmSJKlHy3IO+A477FDr1q1b6mZIkiRphTvppJPOraq1G885PssyAF+3bh0nnnjiUjdDkiRJK1ySH/Zdp1NQJEmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSj+YVgCd5fpIjkpyZpJJsmCVfkuyV5MNJTk9ycZIfJfl4kjuOteWSJEnSFJrvnTBfAfwa+Aaw/Rz5tgAOBU4GPgycBdwIeArwlST/UFXvX2xjJUmSpGk33wD8T6vqTIAkpwLbzpLvcmCPqvrCYGKSg4DvAK9L8sGqunKxDZYkSZKm2bymoMwE3/PId/lw8N2lnw18AfijbpMkSZJWpT4vwrwJcBlwfo91SpIkScvKfKegbJIkDwJ2Bw6tqktnybMvsC/ATjvt1EezJG2CdfsftdRN6MWGA/dc6iZIklaYiY+AJ7k57cLMnwLPmi1fVa2vqt2qare1a9dOulmSJEnSkphoAJ7kpsD/AgU8sKrOmWR9kiRJ0nI3sSkoSdYBn6etmHLvqjplUnVJkiRJ02IiAXiSnWnB93bAfarqm5OoR5IkSZo2Yw/Au+D7WOB6wH2r6qRx1yFJkiRNq3kF4En2Bnbunq4FNk/you75D6vq0C7fdWgj3+uAtwC7Jtl1qLiju3XBJUmSpFVnviPgTwTuMZT20u7xC7RVTgBuANy0+/czZinrnoABuCRJklaleQXgVbXHPPNtALIJ7ZEkSZJWtD7vhClJkiStegbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpR2uWugHSSrNu/6N6r3PDgXv2XqckSVocR8AlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9WheAXiS5yc5IsmZSSrJho3k3zXJkUnOS3JRkuOS3GssLZYkSZKm2Jp55nsF8GvgG8D2c2VM8qfA8cDlwKuB3wBPBj6T5IFVdcyiWytJkiRNufkG4H9aVWcCJDkV2HaOvK+kBel/WVUnd685BPgO8LYkt6yqWnSLJUmSpCk2rykoM8H3xiTZBngwcOxM8N29/kLgXcAtgL9aeDMlSZKklWHcF2HeFtgC+MqIfV/tHg3AJUmStGrNdwrKfN24e/zpiH0zaTuOemGSfYF9AXbaaacxN0ur1br9j1rqJkiSJF3NuEfAt+4efzdi36VDea6mqtZX1W5VtdvatWvH3CxJkiRpeRh3AH5x97jFiH1bDuWRJEmSVp1xB+A/6x5HTTOZSRs1PUWSJElaFcYdgJ9Cm35y5xH77tQ9njjmOiVJkqSpMdYAvFtu8BPAHkn+YiY9ybbAk4AfACeMs05JkiRpmsxrFZQkewM7d0/XApsneVH3/IdVdehA9ucD9wY+m+QNwG9pd8LcEdjTm/BIkiRpNZvvMoRPBO4xlPbS7vELwB8C8Ko6PcldgAOB/YHNabewf4C3oZckSdJqN68AvKr2WEihVfV/wEMW0yBJkiRpJRv3RZiSJEmS5mAALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSerRmqRugpbFu/6N6r3PDgXv2XqckSdJy4wi4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjyYSgCfZNskLkpyS5IIk5yY5Psk+STKJOiVJkqRpsGbcBSbZDPg08NfA+4C3AFsDjwHeC9wKeN6465UkSZKmwdgDcOCOwF2BN1bVfjOJSd4OfA/4RwzAJUmStEpNIgC/bvf4s8HEqrosybnAFhOoU5IkSZoKkwjATwDOB56bZAPwNWArYB/gL4GnTKBOSZIkaSqMPQCvqvOSPBh4F3D4wK4LgIdX1ZHjrlOSJEmaFpNahvBC4FTgtcDDgCcBpwMfTHLfUS9Ism+SE5OceM4550yoWZIkSdLSGnsAnuQ2wPHA0VX1nKr6WFW9m3Zh5i+Ag5Jca/h1VbW+qnarqt3Wrl077mZJkiRJy8IkRsD3A7YEjhhMrKqLgaOAnYF1E6hXkiRJWvYmEYDv2D1eY5Sbq+acT+LiT0mSJGnZm0QA/t3ucZ/BxCTbAw8BzgPOmEC9kiRJ0rI3iZHoNwL/ABzYzQf/MnB94MnAjYCnVdXlE6hXkiRJWvYmsQzhD5PsDvw7cG/g0cAlwMnAs6rqo+OuU5IkSZoWE5mLXVVnAI+bRNmSJEnSNJvUOuCSJEmSRjAAlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknq0ZqkbIGnTrdv/qKVugsao7/7ccOCevdYnSaudI+CSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9mlgAnuT6SV6b5PQklyY5J8nnk9xtUnVKkiRJy92aSRSaZGfgWGBb4N3AacB2wG2BHSdRpyRJkjQNJhKAA+/vyr5tVf18QnVIkiRJU2fsAXiSuwN3BZ5ZVT9Pcm3g2lV18bjrkiRJkqbNJOaAP6h7/FGSTwCXABclOS3JXhOoT5IkSZoakwjAd+0eDwKuDzwOeCJwGXBoksePelGSfZOcmOTEc845ZwLNkiRJkpbeJALw63SPFwD3rKoPVNV7gLsB5wOvSHKNeqtqfVXtVlW7rV27dgLNkiRJkpbeJALwS7rHD1XVZTOJVXUe8HHgj7lqlFySJElaVSYRgP+ke/zFiH0zK6JcbwL1SpIkScveJALwE7rHm4zYN5P2ywnUK0mSJC17kwjAj6TN/94rybYziUluBDwU+EFVnT6BeiVJkqRlb+zrgFfVeUmeDfwn8NUk7wE2B/6pe3z6uOuUJEmSpsVE7oRZVeuTnAs8F3gpcCXwFeCxVfXlSdQpSZIkTYNJ3Yqeqvoo8NFJlS9JkiRNo0nMAZckSZI0CwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUozVL3QCtHuv2P2qpmyAtmJ9bSdK4OQIuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUcG4JIkSVKPDMAlSZKkHhmAS5IkST0yAJckSZJ6ZAAuSZIk9cgAXJIkSeqRAbgkSZLUIwNwSZIkqUe9BOBJtk5yVpJK8tY+6pQkSZKWo75GwF8C7NBTXZIkSdKyNfEAPMkdgH8BXjzpuiRJkqTlbqIBeJJrAQcB/wN8dJJ1SZIkSdNgzYTL3w+4JfDwCdcjSZIkTYWJBeBJbgr8B/CSqtqQZN1G8u8L7Auw0047TapZG7Vu/6OWrG5JWgpL8f/ehgP37L1OSVouJjkF5R3AWcDr55O5qtZX1W5VtdvatWsn2CxJkiRp6UxkBDzJXsD9gLtX1e8nUYckSZI0jcYegCfZgjbq/SngF0lu1u3asXvcrks7t6rOH3f9kiRJ0nI2iSkoWwFrgT2BHwxsx3b79+qeP2kCdUuSJEnL2iSmoFwEPHJE+lrg7bQlCd8NfHsCdUuSJEnL2tgD8G7O90eG0wdWQTmjqq6xX5IkSVoN+roVvSRJkiQmfyOeP6iqDUD6qk+SJElajhwBlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknpkAC5JkiT1yABckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknq0ZqkbIElSH9btf1TvdW44cM/e65S0/DkCLkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHYw/Ak9wiyUuSfDXJOUkuSHJykhcm2Wbc9UmSJEnTZBIj4E8A9gPOAF4CPAf4PvAy4PgkW02gTkmSJGkqrJlAmR8BXllVvxlIe2eSHwAvBJ4IvHUC9UqSJEnL3thHwKvqxKHge8Zh3eOfj7tOSZIkaVr0eRHmTbrHs3usU5IkSVpWJjEF5RqSXAv4d+By4IOz5NkX2Bdgp5126qNZkqQlsm7/o5a6CRqjpejPDQfu2Xud0rj0NQL+RuBOwL9X1fdHZaiq9VW1W1Xttnbt2p6aJUmSJPVr4gF4kpcCTwfWV9UrJ12fJEmStJxNNABPcgDwIuC9wFMmWZckSZI0DSYWgCd5MfBi4BDgSVVVk6pLkiRJmhYTCcCT/DtwAHAo8PiqunIS9UiSJEnTZuyroCR5GvAfwI+AY4DHJhnMcnZVHT3ueiVJkqRpMIllCP+qe9wJeN+I/V8ADMAlSZK0Kk3iTpj7VFXm2PYYd52SJEnStOjzTpiSJEnSqmcALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSerRmqRsgSZLGZ93+Ry11EzRGq6U/Nxy451I3oVeOgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPXIAFySJEnqkQG4JEmS1CMDcEmSJKlHBuCSJElSjwzAJUmSpB4ZgEuSJEk9MgCXJEmSemQALkmSJPVoIgF4ks2S7Jfke0kuTfLjJK9Lss0k6pMkSZKmxaRGwN8AvB74LvAM4AjgmcAnkjjqLkmSpFVrzbgLTHJrWtD90ap6+ED6WcCbgUcDHxx3vZIkSdI0mMRo9GOAAG8cSj8IuBjYawJ1SpIkSVNhEgH4XwFXAicMJlbVpcDJ3X5JkiRpVZpEAH5j4Nyq+t2IfT8Fdkiy+QTqlSRJkpa9VNV4C0zOAK5dVTuN2HcIsDdwvao6f2jfvsC+3dNdge+PtWEr2w7AuUvdCI2N/bny2Kcri/25stifK89C+3Tnqlo7qcaMMvaLMGnzvP9oln1bDuS5mqpaD6yfQHtWvCQnVtVuS90OjYf9ufLYpyuL/bmy2J8rzzT06SSmoPyMNs1kixH7dqRNT7lsAvVKkiRJy94kAvCvd+XuPpiYZEvgdsCJE6hTkiRJmgqTCMAPAwr4l6H0JwNbAx+YQJ2rnVN3Vhb7c+WxT1cW+3NlsT9XnmXfp2O/CBMgyVuApwMfAz4F3Ip2J8wvA/eqqivHXqkkSZI0BSYVgF+LNgK+L7COdiXqYcC/V9WFY69QkiRJmhITCcAlSZIkjTaJOeDqJNk2yQuSnJLkgiTnJjk+yT5JMpDvgCQ1y/bsEeVulmS/JN9LcmmSHyd5XZJtZmnHrkmOTHJekouSHJfkXrPkXVDZq0mSGyZ5Z3dMLkvyoyRvSrL9iLwTO+b253jMtz89P5efJM9PckSSM7t+2LCR/FN5Pi6k7Gk24f6c7dwd+Wu8/bnpFtKfSXZP8uYkX05yYZd/nznyr5zzs6rcJrDRvtwcB1wBvIc2HedfgK/RLlJ91UDeA7jqwtW9hrZbjSj7TV3+j9Iubn098Hvgc8BmQ3n/FPgVcDbwfOCpwDe7/PfZlLJX00Zb234DcBnwFuAfu8fLuuO5dR/H3P5ckv70/FxmW3cMfgUcDfwa2DBH3qk8Hxda9jRvE+7PAr444tz9u+X8WZnmbYH9eQAtTvoO7TrBAvaZI/+KOT+XvKNW6gbcuevINwylbw6cCZw/9AEsYN08yr01cCXwX0Ppz+jKeOxQ+uHdh/t2A2nbAj+k3W00iy17NW3AG7tj8Jih9Md06S/q45jbn0vSn56fy2wDdhn496nM/Qd+Ks/HhZQ97duk+rPbV8DB82yH/dl/f94Q2Kb79yOYIwBfaefnknfUSt2A+3ed9pwR+04Afjrw/IAu7zrgusCaOcp9WZf3bkPpWwIXAZ8aSNsGuBT43xHl/FtXzu6LKXu1bcC3aHdwHf7PfTPgEuCMSR9z+7P//uzSPD+X8cYcf+Cn9XxcaNkraRtnf3bpBRxMG/zado567c+e+3NE3o0F4Cvq/HQO+OScAJwPPDfJI5Ps1M0XeiXwl7Q/6sO+DfwGuDRtrvgDR+T5K9q3tBMGE6vqUuDkbv+M2wJbAF8ZUc5XB8pbTNmrzRbApdWdYTOqLal5CbBLkh2Y7DG3P8dnvv05yPNz+kzr+bjQsleLxR6XR9C+cF+Q5JdJ3pJku00s2/7s34o6Pw3AJ6SqzgMeTJv/dDjtZ4nvAU8DHl5VBw1kP5+2aPwzgIfQ5hPtDBw14mKEGwPnVtXvRlT7U2CHJJsP5J1JH5UXYMdFlr3afAe4XpLbDSZ2z6/XPd2JyR5z+3N85tuf4Pk5zab1fFxo2avFYo7LCbQBr0cAj6PN5306cFySbTehbPuzfyvq/FyzsQzaJBfSfn75OHA8cH1aAP7BJA+pqqMBquqNwy9M8p7utW9I8pG6av30rYFRHxBoP4nM5Lmse2SW/IN5Gfj3fMtebd4IPBQ4PMm/0Prm1l3674Fr047NJI+5/Tk+b2R+/en5Od2m9XxcaNmrxYKPS1XdcSjfIUm+Dbwc+OfucTFl25/9W1HnpyPgE5LkNrSg++iqek5Vfayq3g3cFfgFcFDaDYtGqqpfAe8Etgf+emDXxbSfPkbZciDP4OOo/MN5F1r2qlJVxwGPBq4DHEX7ReMTwOeBT3bZfstkj7n9OSYL6M/ZXu/5OR2m9XxcaNmrxbiOy2togdSem1C2/dm/FXV+GoBPzn60jjhiMLGqLqb9wd+ZdlHXXDZ0j4NzUX9G+ylkVMfvSPsJ5bKBvDPpo/LC1X9CWUjZq05VHQHcBLg9cHfgxlX1lC7tcuB0JnvM7c8xmmd/zmVD9+j5uXxN6/m40LJXi7Ecl6r6fVfW8Lm7kLLtz/6tqPPTAHxyZjph1Cj3mqHH2dy8ezx7IO3rtH7bfTBjki2B2wEnDiSfQvuJ5M4jyr5T9ziYfyFlr0pVdUVVnVxVx1XVL5P8MS2A+0L35WqSx9z+HLN59OdcPD+Xv2k9Hxda9moxluPSHfObcPVz1/5c/lbW+bnYpWXcNrqczhtoS9E8dyh9e9q3p1/TAvA1wHYjXv8ntEXezwW2Gki/DXOvVbnXUPoRtLUq/2IgbWatytO4+jqYCyp7tW/dyXp4d8zu2ccxtz/77U/Pz+W/sfF1hqfyfFxI2StpG3N/3mCWMl7D6L/P9mfP/TmUd2PLEK6o83PJO2elbrQpJr/qOvRQ4CnAC4Czus58apdve+A84L3Ac2l3X3otbeWFy4FHjij7LVx1t6YnAa+jXTh2LNe8W9PNaMH+2cD+XHW3psuB+29K2atp606s79Iu2HkS8CzaN9wCXtDXMbc/++1Pz8/luQF7Ay/qtrO7Ppp5vndfx3g5lT3N26T6kzYQ9hXgFbS/wc+mrYJStOXitlps2fbn2Ppz54F9H+qO538NpO3c1zHvuz+XvKNW8ka7Ven7gJ90nfhb2i1xHzaQZwvgXbSfNM7r8v0c+AizLOROm9byLNrdln5Hm2v0ema5yQBwK+C/aUHDxcCXmOVWqQste7VstJs4fJj2BerS7sT7zGwn2iSPuf3ZX396fi7PjfYHsWbZju3zGC+Xsqd5m1R/0pYN/Ux3nC+l3VDlZNpg2Jb259L3J7DHHHkL2KOvY953f6YrRJIkSVIPvAhTkiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPTIAlyRJknpkAC5JE5Ckkhy81O1YjCRbJ3lzkh8luSLJhqVukyStJAbgkqZGkj26wLaSPGmWPJXkk323bYV5HvAM4DBgH+Bf5so80CeV5MokFyQ5M8nHkjw+yVaTb7IkTY81S90ASVqk/0jygaq6ZKkbsgLdFzilqp6zgNecDLyu+/fWwE7A/YD3AC9M8vCq+tZYWylJU8oRcEnT6ETgxmxkZHa1SHKtJFuPscg/Bn69wNf8tKre323rq+pFVbU78ChaMP7pJNcbYxslaWoZgEuaRocDJwHPS3KDjWWebT52kn26fXsMpB3Qpf1Zkjcm+XmSi5L8b5JduzwPS/KNJJck2ZBk3znqvk+Srya5OMkvkrwpyTYj8m2X5FVJTk/yuyTnJPlQkl1mafN9kvxbkjOAS2mB7lzHYE2S5yX5bpJLk/yqmyJym+GygZsC9xiYVnLAXGXPpaqOAF4N3Ah42kBdmyV5YZIvdsflsm7O+TsG+zTJDbt975/lfb29m/ayc/f8+knekOSMgfd5UpKFjOZL0kQZgEuaRkWbp7wd8MIJ1fE+4C+AV9CmVtwJ+EySvYG3AUcCzwHOA/4zyV1HlHGHLt9XgGcDxwHPBD6e5A///ybZDjgeeCpwFG3+9VuBewFfmwkuh7wWeDRwEPDPwPc38n4+ABwI/KRr9zuBewJfSXL7Ls8Xgb2Bc4Hvdf/eG/joRsremHd1j3sOpG3eteMHwGtox+Vo4InAsUk2B6iqs4GPAw9Psv1goUm2BB4DHFNVP+ySjwCeDnyadhxfApwA7LGJ70GSxsY54JKmUlX9b5KjgacmedNAADYuvwAeXFUFkORc4E3A24FbV9WPuvTDgB/TRne/NFTGbYC/raoju+dvT/ImWrD5KODDXfpLgF2AOw3Ok+5G7U8B/oN2MeSgrYDbV9XFG3sjSe7b1Xc48OiB93QY8A3gzcDdqupM4MwkLwPOrqqRo84LVVUbklwA3GIg+XfAjYbm8L8zyfG0gP2hXXsB1gMPBx5LO/4zHg5s3+Wf+SJzL+AdVfX0cbRdkibBEXBJ0+x5tJHUl06g7DfPBKqd47rH/54JvgGq6hza6PPNR5Tx/YHge8aB3ePfAiQJ8Pe00eefJtlhZgMuAr5Ku5hx2DvmE3wP1gW8fPA9VdW3gU8Cd02ydp5lLdZvgesO1F0zwXc3h3377j1/rstyx4HXHg2cRRsdH/RE4Fe0XxkALqEF9ndMsm7cb0CSxsUAXNLUqqpvAh8C/j7Jbcdc/JlDz8/rHs8akfc8YNRc9P8bTqiqnwPn00a8AdZ2r70fcM6I7b7ADUeUfdqcrb+6mwJXjmoPcOpAnkm6Li0I/4Mkj0ryNVrgfB7t/c4c9z9csNl9aXgXcIckt+teuwttWsmhVXVZl+8y2oW5fw6cleQ7Sd6S5N6Te1uStHAG4JKm3YuAy4FXLeK1c03Du2KB6RmRViPShvPO/PsYWrA9arv/iDLmO/o9W9t6041GX4eBeepJHkZbZxzaHPa/ob3XB3Rpw3+f3kPr55lR8CfQ3te7BjNV1TuBdcCTadNrHgEck+TDSNIy4RxwSVOtqs5K8g7gn5Pcc5ZsvwauPyJ9lxFp4/RnwwlJbkS7eHRmpPcc2oj4davqmAm14wxaEH8r4NuztHHUyP64zNw06aiBtL1pq7fcc3AqTZJbjiqgqn6R5BO0Xzv2Bx4HfK2qvjMi789pgfm7klwLOBR4TJLXVdXXx/KOJGkTOAIuaSV4GW16w2yj4KcBdx5cK7tbk/rxE27XrkkeOpT2vO7xSICqupK2QsnuSR4xqpAkf7SJ7Tiye3x+N+d8ptw/Bx4MfKmbyz52SR4JPBf4GW31mBlX0H4hGFwNJrRfNGZzEG1qyjuBmzA0+p1k6wyth15VV3DVl45RX8IkqXeOgEuaelV1bpLXMPvFmG8F3g98LsmhtJUzngz8kHbTmUk5BXh/koNoy+3dkzYl4gtcNf0C2lKKdwEOT3I47cLLy4CdgQfR1jzfZ7GNqKqju3IfDVwvySdp7/tptFHoZy627AE7Jtmr+/dWXHUnzN2B04GHVdX5A/k/QlvF5HNJDgGuTVv5ZK4bCn2G1md70S5QHZ5WcgvgC0k+Rpvbfh5t1P+faCP8xyFJy4ABuKSV4vW0dbRvNLyjqj6Q5Ma09aFfT5v+8RLahYl3HM4/Rt8A/hV4OfAU2ij9W4EXdCPfM+37TZK7AM+iLRf4ENp855/QljZ8F5vu77v27ENb1/wi2heBf6uqU8ZQ/u1oUz3oyj4H+BZtzvaHhpYbpKo+nOQ6wH60Nc3PAz4B7E9b2eQaqurKJO+m9d1hVXXhUJYf0+aK35MWzG8B/JQ2cv6qBawaI0kTlauvsiVJ0vKV5Lm0qUZ/XVVfWer2SNJiGIBLkqZCkjW0lVQuqqpxLzspSb1xCookaVlLclPgzrSpObvQbj8vSVPLAFyStNzdA3gvcC7wkqpyTW9JU80pKJIkSVKPXAdckiRJ6pEBuCRJktQjA3BJkiSpRwbgkiRJUo8MwCVJkqQeGYBLkiRJPfr/On6GbY5O2MQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(n_days_modn_strat, 21);\n",
    "plt.title(\"Duration of 'Counting' Strategy\", fontsize=18);\n",
    "plt.xlabel(\"Number of Days\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ooof, the \"sophisticated\" mod N solution is taking around 9 times as many days to execute as the simple counting strategy!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Lightbulb Channel Bit Rate Part 2\n",
    "\n",
    "Lets briefly return again return to the idea of how many bits/day transmitted through the lightbulb by this strategy. The message which is transmitted on each day is received on the very next day 100% of the time so unlike in the counting strategy we don't need the inital rate of 1/N for the receiver to be selected before a transmission can occur. \n",
    "\n",
    "Likewise the light has been left on almost 50% of the time which is close to the theoretical maximum entropy switching rate of 1/2 and so using the same naive entropy estimate as we did earlier we get a bit rate estimate which is close to the physical maximum of 1 bit per day!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.43936372435689397"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(light_on_fractions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9893649607680294"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_entropy(np.mean(light_on_fractions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a couple things going on here. \n",
    "\n",
    "Firstly we actually are trying to transmit more information than in the counting strategy. In the counting strategy we don't try to say which of the participants have been in the room but only that at least one more has been which means our counting system can only be in 1 of 100 states and so we really only need to communicate $log_2(100)~6.6$ bits. But in the mod N strategy we communicate which of the particular prisoners have been in the room which is a message space which spans 100 bits (one for each participant). \n",
    "\n",
    "Secondly although every day a message is delivered to a valid receiver, since we have 100 receivers the information contained in those messages is also divided up 100 different ways.\n",
    "\n",
    "But even if we need to transmit 100 bits of information to all 100 particpants. If our communication bit rate is close to 1 per day then shouldn't we achieve a proof after something fairly close to 10,000 days instead of nearly 100,000 days like the simulations seem to suggest?\n",
    "\n",
    "Well the same naive entropy estimate as we used for the counting strategy won't fly here. Saying that the light is on 50% of the time is a little misleading. It is true that the light is on roughly 50% of the time but saying that it is unpredictably transitioning from off to on from the perspective of the receiver is a stretch.\n",
    "\n",
    "It starts being off almost all the time and then ends up being on nearly all the time. At the beginning the entropy of the light state is very low because the messages aren't really being passed and later on the information contained in the messages being passed is known to almost all the particpants and so isn't really informative. Information is only really being efficiently passed around for the days near the middle of the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "on_prob = scipy.ndimage.filters.gaussian_filter(light_states.astype(float), 100)\n",
    "plt.plot(on_prob, label=\"Light 'On' Probability\")\n",
    "plt.plot(calc_entropy(on_prob), label=\"Naive Entropy [bits]\")\n",
    "\n",
    "plt.legend()\n",
    "plt.title(\"Mod N Example Trajectory\")\n",
    "plt.xlabel(\"Days\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Better Set of Messages?\n",
    "\n",
    "The slow ramp up of the amount of information being transmitted early on is a function of the fact that the participants themselves have very little information available to them which seems difficult to change. \n",
    "\n",
    "But the low information/entropy of the late stages of the process are because each message stops being surprising to the receiver. The chances become very high that the light is being left on precisely because the participants all already have most of the other participants in their known sets and so the message start to lose their informativeness. \n",
    "\n",
    "By ramping up the size of the known set being indicated by the later messages we can decrease the likelihood that a random participant has access to that information. This decreases the likelihood that the message will be able to be sent but also greatly increases the chance that the receiver gets some new information out of it.\n",
    "\n",
    "Instead of coming up with a schedule which sends all possible sets of singlets, then pairs, then triplets etc. It is much easier to just generate a pseudorandom sequence of messages and just enforce that sequence to be the same between all participants. Because of the way that the simulation function is coded we don't even need the message function to be deterministic since it reuses whatever was returned by the previous day for the next day's message passing. This works well enough for our simulation purposes though obviously in practice the messages would need to be frozen ahead of time. \n",
    "\n",
    "I picked some arbitrary thresholds which seem to do well for a set of 100 participants. Note that it is also important that we continue to include the possibility of transmitting singlet messages since if we do not then we can become very unlucky and miss the initial sharing of any 1 particular singlet. If for example the first participant is never selected on a day corresponding to sending the singlet message for themselves and we then transition to sending only double participant messages then we will have locked ourselves in to a no win situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def progressive_messages(day_idx, N):\n",
    "    max_tuplet_size = 1\n",
    "    if day_idx > 5*N**2:\n",
    "        max_tuplet_size = 2\n",
    "    if day_idx > 6*N**2:\n",
    "        max_tuplet_size = 4\n",
    "    if day_idx > 6.5*N**2:\n",
    "        max_tuplet_size = 7\n",
    "    if day_idx > 6.8*N**2:\n",
    "        max_tuplet_size = 10\n",
    "    tuplet_size = np.random.randint(1, max_tuplet_size+1)\n",
    "    return [int(i) for i in np.unique(np.random.randint(N, size=(tuplet_size,)))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68240\n"
     ]
    }
   ],
   "source": [
    "res = simulate_message_strategy(\n",
    "    100,\n",
    "    message_fn=progressive_messages,\n",
    ")\n",
    "print(len(res[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "on_prob = scipy.ndimage.filters.gaussian_filter(res[0].astype(float), 100)\n",
    "plt.plot(on_prob, label=\"Light 'On' Probability\")\n",
    "plt.plot(calc_entropy(on_prob), label=\"Naive Entropy [bits]\")\n",
    "\n",
    "plt.legend()\n",
    "plt.title(\"Example Trajectory\")\n",
    "plt.xlabel(\"Days\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see you can see by periodically increasing the size of the typical known set required to send the messages we can easily keep the message entropy high almost to the end of the process and shorten the number of days required. \n",
    "\n",
    "But we can't really apply this same strategy to try and cut down on the length of the initial ramp up period where we are stuck sending singlet messages till the participants become more generally well informed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Count Passing?\n",
    "\n",
    "There is a huge gap between the average time for each participant to have been chosen at least once which is roughly proportional to $N$ days and the fastest detection of that fact after roughly $N^2$ days. Even though the message passing strategies up above performed much worse than the counting strategy perhaps we can learn something from it in order to come up with another faster strategy.\n",
    "\n",
    "The counting strategy is faster in no small part because it is trying to communicate something fundamentally much simpler, a lower bound on a count of those chosen, as opposed to the exact identity of those chosen. The disadvantage of needing to communicate so much more information completely overwhelms the advantage in terms of the efficiency of transmission.\n",
    "\n",
    "Instead of making most of the participants turn the light on only once what if everyone kept a running sum of the incoming count messages they have received and the outgoing messages they have sent? This amounts to the same thing as simply turning the light on once and then leaving it alone if every day the light indicates the same number of upstream counts but what if we copy the message passing strategy and change the size of the increments depending on the day? \n",
    "I have a suspicion that such a strategy could be used to beat the simple counting strategy somehow but I haven't been able to quite manage it yet. I may come back to this post and make tweaks in the future but I think I have spent quite enough time thinking about this riddle. I will leave my most recent attempt code here just in case.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RampCountFn(object):\n",
    "    \n",
    "    def __init__(self, ramp_lengths):\n",
    "        self.ramp_lengths = ramp_lengths\n",
    "        schedule = []\n",
    "        for ramp_n in ramp_lengths:\n",
    "            schedule.extend(range(1, ramp_n+1))\n",
    "        self.schedule = schedule\n",
    "        \n",
    "    def __call__(self, day_idx):\n",
    "        if day_idx >= len(self.schedule):\n",
    "            return 1\n",
    "        else:\n",
    "            return self.schedule[day_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "rfn = RampCountFn(np.repeat(range(10, 2, -1), 100))\n",
    "#plt.plot([rfn(i) for i in range(1000)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_count_passing_strategy(\n",
    "    N_members, \n",
    "    n_transfer_fn,\n",
    "    max_days=150000,\n",
    "):\n",
    "    light_state = False\n",
    "    current_counts = np.ones(N_members, dtype=int)\n",
    "    \n",
    "    light_history = []\n",
    "    member_history = []\n",
    "    \n",
    "    carry_amt = 0\n",
    "    \n",
    "    for day_idx in range(max_days):\n",
    "        ci = np.random.randint(N_members)\n",
    "        if light_state:\n",
    "            current_counts[ci] += carry_amt \n",
    "\n",
    "        available = current_counts[ci]\n",
    "        \n",
    "        if available >= N_members:\n",
    "            break\n",
    "        \n",
    "        carry_amt = n_transfer_fn(day_idx)\n",
    "        \n",
    "        light_state = False\n",
    "        if available >= carry_amt:\n",
    "            #transfer_prob = 0.5*carry_amt/available\n",
    "            transfer_prob = 1.0\n",
    "            if ci == 0:\n",
    "                transfer_prob = 0.0\n",
    "            leaves_light_on = np.random.random() < transfer_prob\n",
    "            if leaves_light_on:\n",
    "                light_state = leaves_light_on\n",
    "                current_counts[ci] -= carry_amt\n",
    "        \n",
    "        light_history.append(light_state)\n",
    "        member_history.append(ci)\n",
    "    \n",
    "    return np.array(light_history), np.array(member_history), current_counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = simulate_count_passing_strategy(\n",
    "    N_members=100, \n",
    "    n_transfer_fn=rfn,\n",
    "    max_days=100000,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12783"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(res[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "on_prob = scipy.ndimage.filters.gaussian_filter(res[0].astype(float), 100)\n",
    "plt.plot(on_prob, label=\"Light 'On' Probability\")\n",
    "plt.plot(calc_entropy(on_prob), label=\"Naive Entropy [bits]\")\n",
    "\n",
    "plt.legend(loc=4)\n",
    "plt.title(\"Example Trajectory\")\n",
    "plt.xlabel(\"Days\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_switched_count_passing(\n",
    "    N_members,\n",
    "    count_schedule,\n",
    "    #keep_probs,\n",
    "    accumulator_index=0,\n",
    "    max_days=100000,\n",
    "):\n",
    "    light_history = []\n",
    "    amt_history = []\n",
    "    count_history = []\n",
    "    \n",
    "    light_state = False\n",
    "    prev_day_amt = 0\n",
    "    \n",
    "    current_counts = np.ones(N_members, dtype=int) #start everyone off with 1 count to give\n",
    "    \n",
    "    accumulator_index = None\n",
    "    \n",
    "    for day_idx in range(max_days):\n",
    "        count_history.append(current_counts.copy())\n",
    "        \n",
    "        ci = np.random.randint(N_members)\n",
    "        start_amt = current_counts[ci]\n",
    "        cur_day_amt = count_schedule[day_idx % len(count_schedule)]\n",
    "        \n",
    "        #cur_keep_prob = keep_probs[min(len(keep_probs)-1, day_idx), start_amt]\n",
    "        #is_sticky = np.random.random() < cur_keep_prob\n",
    "\n",
    "        #target_lumpyness = target_schedule[day_idx % len(target_schedule)]        \n",
    "        #prior to aggregating any passed counts determine if we are going to pass forward if we can\n",
    "        #is_sticky = current_counts[ci] > target_lumpyness\n",
    "        #print(\"cur day amt\", cur_day_amt)\n",
    "        \n",
    "        is_sticky = ci == accumulator_index \n",
    "        \n",
    "        if light_state:\n",
    "            #we got passed some aggregated counts!\n",
    "            current_counts[ci] += prev_day_amt #add them into our total\n",
    "            light_state = False #and turn off the light temporarily\n",
    "                \n",
    "        #print(current_counts[ci], cur_day_amt, target_lumpyness)\n",
    "        \n",
    "        #print(\"our amount\", current_counts[ci])\n",
    "        \n",
    "        #check if our count total is enough to declare \n",
    "        if current_counts[ci] >= N_members:\n",
    "            break #We did it!\n",
    "        \n",
    "        if current_counts[ci] >= cur_day_amt:\n",
    "            #print(\"have enough to pass message\")\n",
    "            #we have enough aggregated counts to leave the light on\n",
    "            if is_sticky:\n",
    "                #print(\"Not going to pass!\")\n",
    "                #we are above the target \"lumpyness\" threshold hold on to our counts\n",
    "                light_state = False\n",
    "            else:\n",
    "                #print(\"passing!\")\n",
    "                #we are below the lumpyness target lets go ahead and pass the love\n",
    "                light_state = True\n",
    "                current_counts[ci] -= cur_day_amt #store the count amount in the light state\n",
    "        else:\n",
    "            pass\n",
    "            #print(\"don't have enough to pass a message\")\n",
    "        \n",
    "        prev_day_amt = cur_day_amt\n",
    "        \n",
    "        if light_state:\n",
    "            amt_history.append(cur_day_amt)\n",
    "        else:\n",
    "            amt_history.append(0)\n",
    "        \n",
    "        light_history.append(light_state)\n",
    "        \n",
    "    return np.array(light_history), np.array(count_history), np.array(amt_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [],
   "source": [
    "aggregator_counts = np.zeros((5000, 100))\n",
    "second_to_max_counts = np.zeros((1000, 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "count_schedule = np.hstack([\n",
    "    np.tile(np.arange(1, 31), 4), \n",
    "    np.tile(np.hstack([np.arange(1, 8), np.repeat(7, 100)]), 10),\n",
    "    np.tile(np.hstack([np.arange(1, 6), np.repeat(5, 100)]), 10),\n",
    "    np.tile(np.hstack([np.arange(1, 4), np.repeat(3, 100)]), 10),\n",
    "    np.tile(np.hstack([np.repeat(1, 10), np.arange(1, 3), np.repeat(2, 100)]), 100),    \n",
    "    #np.tile(np.arange(1, 5), 10), \n",
    "    #np.ones(10000, dtype=int),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f49aa483550>]"
      ]
     },
     "execution_count": 361,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(count_schedule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([37, 51,  4,  3,  3,  0,  1,  0,  0,  0,  1])"
      ]
     },
     "execution_count": 362,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bincount(cnts[1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6860213681045484"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keep_probs[1000][27]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "lengths = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "....................................................................................................."
     ]
    }
   ],
   "source": [
    "for i in range(101):\n",
    "    print(\".\", end=\"\")\n",
    "    \n",
    "    #keep_probs = unique_max_counts/(0.0001 + np.sum(unique_max_counts, axis=1, keepdims=True))\n",
    "    \n",
    "    keep_probs = np.cumsum(unique_max_counts, axis=1)\n",
    "    keep_probs /= (keep_probs[:, [-1]] + 0.0000001)\n",
    "    keep_probs = np.clip(keep_probs-0.5, 0, 1.0)\n",
    "    keep_probs /= (keep_probs[:, [-1]] + 0.0000001)\n",
    "\n",
    "    light_states, cnts, pamts = simulate_switched_count_passing(\n",
    "        N_members=100,\n",
    "        max_days=20000,\n",
    "        count_schedule = count_schedule,\n",
    "        keep_probs = keep_probs,#np.repeat(0.3, 100).reshape((1, -1))\n",
    "    )\n",
    "    short_counts = cnts[:5000]\n",
    "    maximum_vals = np.max(short_counts, axis=1, keepdims=True)\n",
    "    n_maxima = np.sum(short_counts == maximum_vals, axis=1)\n",
    "    \n",
    "    #forced_unique_max = #maximum_vals.reshape((-1,))+np.where(n_maxima > 1, 1, 0)\n",
    "    for day, (val, degeneracy) in enumerate(zip(maximum_vals, n_maxima)):\n",
    "        if degeneracy == 1: \n",
    "            unique_max_counts[day, val] += 1\n",
    "    \n",
    "    lengths.append(len(light_states))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 366,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f49aa431e50>"
      ]
     },
     "execution_count": 366,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(keep_probs, aspect=\"auto\")\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f49a31917f0>]"
      ]
     },
     "execution_count": 367,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuwAAAFtCAYAAABcJD8cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAueUlEQVR4nO3df5RndX3n+ecL2KYDvUqS7vFIa+ssI0hwELXABrNGkJMjMpGcGIm4kKBAH7OAA7tmI8I2CI7tksXmiOyQxsgI08xhNC1rJ24UZkMvDjJYQK+AwYEAwsJMh1bkV9OA4b1/3PvVb3+5Vf2t7i7qNjwf53zPp+pz3/dzP3Wuja+69bn3pqqQJEmS1E+7zPUEJEmSJE3NwC5JkiT1mIFdkiRJ6jEDuyRJktRjBnZJkiSpxwzskiRJUo/tNtcT6LuFCxfWG9/4xrmehiRJkl7Gbr311o1Vtahrm4F9K974xjcyOTk519OQJEnSy1iSH0+1zSUxkiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjYwX2JPsmOT/JzUkeTfJkkvVJzk6y50jtIUm+mOQ/JnkqSSU5cZqxd0lyZpK7k2xO8lCSi0bHHarfL8m1SR5L8nSSG5McsSPGliRJkvpm3CvsHwPOBP4eOB/4E+BHwGeBm5L8ylDt+4FTgb2A/3eMsVcCXwB+CJwOfA34BLA2yRbzS7IPcBNwKHBhO48FwLeTHLk9Y0uSJEl9NO6bTr8OrKiqx4f6LktyD3A2cBLwpbb/XwN/VlVPJ/l94LCpBk1yAE2QXlNVHxzqvx/4IvBh4OqhXVbQ/CLwjqpa39ZeCdwFXJrkzVVV2zi2JEmS1DtjXWWuqsmRsD5wTdu+Zah2Q1U9PebxjwMCXDzSfzmwCTh+0NEuY/kAcMMgrLfHewr4MrAvcPC2jC1JkiT11fYuC3ld227Yxv0PBl4AbhnurKrNwHq2DOAHArsD3+sY5+ah8bZlbEmSJKmXtjmwJ9kVWA78nG1fWrI3sLGqnu3Y9jCwMMm8odpBf1ctwOJtHHsLSZYlmUwy+eijj271h5AkSZJmy/ZcYb8YWAosr6ofbeMYewBdgRpg81DNcNtVP1o707G3UFWrqmqiqiYWLVo0xRCSJEnS7NumwJ7kAuA0YFVVrdiO42+iWebSZf5QzXDbVT9aO9OxJUmSpF6acWBPch5wDnAF8PHtPP4jNEtTuoL1YpolLc8N1Q76u2phy+UyMxlbkiRJ6qUZBfYk5wLnAlcCJw8eobgdvt/O4ZCR48wHDgImh7rvoFnicmjHOEvbdrh+JmNLkiRJvTR2YE+yHDgPuAr4aFW9sAOOfw1QwBkj/afQrC9fPehoH9+4FnhPkrcOzWsBcDJwD1s+EWbssSVJkqS+GuvFSUlOBT4DPAhcD3wkyXDJhqq6rq19A3BC239A2/5OksEjIK+qqh8DVNUdSS4FTkuyBvgWsD/N20jX8eKnz5wFvBf4TpKVwBM0AXwxcPTwFf9tGFuSJEnqnXHfdDp4ZvkS4Ksd29cB17Vf/1PggpHtv9d+AL4L/Hho2xnAA8Ay4GhgI3AJzdNntriKX1X3JnkX8HngU8A84DbgfVV1fce8xh5bkiRJ6qNs/zL0l7eJiYmanHS5uyRJkmZPkluraqJr2/a+6VSSJEnSLDKwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqcfGCuxJ9k1yfpKbkzya5Mkk65OcnWTPjvr9klyb5LEkTye5MckRHXXnJalpPs/PoP6THePvkuTMJHcn2ZzkoSQXdc1ZkiRJ6qPdxqz7GHAq8E1gNfA8cDjwWeDYJEur6hmAJPsANwE/By4EHgdOAb6d5Kiqun5o3DXAvR3HOxD4E2DtFPM5E9g40ndrR91K4BPAN4CLgP3b79+W5MiqemG6H1qSJEmaa+MG9q8DK6rq8aG+y5LcA5wNnAR8qe1fAewFvKOq1gMkuRK4C7g0yZurqgCq6gfAD0YPluTP2y//Yor5XFtVD0w34SQHAKcDa6rqg0P99wNfBD4MXD3dGJIkSdJcG2tJTFVNjoT1gWva9i0A7VKTDwA3DMJ6u/9TwJeBfYGDpztWkj1owvTDwN9MU/eqJNP9wnEcEODikf7LgU3A8dPNQ5IkSeqD7b3p9HVtu6FtDwR2B77XUXtz204b2IFjgVcBV1TVP05R8wOapTabk9yU5KiOmoOBF4BbhjurajOwfox5SJIkSXNumwN7kl2B5TRr1QdLS/Zu24c7dhn0Ld7K0CcBBXylY9vPgFU0S12OAc4C3gD8dZITR2r3BjZW1bNTzGVhknlbmYskSZI0p8Zdw97lYmAp8Omq+lHbt0fbdoXkzSM1L5JkP+A3gf9QVfePbq+qizv2+QpwJ7Ayydfb5TeD43TNY3Quz3WMuQxYBrBkyZKppitJkiTNum26wp7kAuA0YFVVrRjatKltd+/Ybf5ITZeT2vbL486lqn4CXEZzo+thI3PpmsdW51JVq6pqoqomFi1aNO5UJEmSpB1uxoE9yXnAOcAVwMdHNj/Stl3LXgZ9XctlaG8g/UPgpzSPYZyJB9p24chcFibpCu2LaZbLvOjquiRJktQnMwrsSc4FzgWuBE4ePJ5xyB00y1AO7dh9adtOTjH87wCvAa6aYt35dN7UthuG+r5P8/MdMlyYZD5w0DTzkCRJknpj7MCeZDlwHnAV8NGulw6168fXAu9J8tahfRcAJwP3MPLUliGD5TCdz15PsluSV3f0vx74Y+AnNC9sGriG5ubVM0Z2OYVm7frqKeYhSZIk9cZYN50mORX4DPAgcD3wkSTDJRuq6rr267OA9wLfSbISeIImJC8Gju64Kk+SvYH3AbdU1R1TTGMBcH+Sa4G/Ax4D9qP5RWABcNzgbasAVXVHkkuB05KsAb7FL990ug5fmiRJkqSdwLhPiRk8s3wJ8NWO7euA6wCq6t4k7wI+D3wKmAfcBryvqq6fYvwTgV2Z/mbTZ4C/BN4J/C5NSN9I8wvEhVXVdeX+DJr17cuAo9v6S4DlXX8hkCRJkvomHRe8NWRiYqImJ13uLkmSpNmT5Naqmujatr1vOpUkSZI0iwzskiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjBnZJkiSpxwzskiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjBnZJkiSpxwzskiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6rGxAnuSfZOcn+TmJI8meTLJ+iRnJ9mzo36/JNcmeSzJ00luTHLEFGPXFJ+npqifydi7JDkzyd1JNid5KMlFXXOWJEmS+mi3Mes+BpwKfBNYDTwPHA58Fjg2ydKqegYgyT7ATcDPgQuBx4FTgG8nOaqqru8Y/0Zg1Ujf86NF2zD2SuATwDeAi4D92+/fluTIqnphzJ9fkiRJmhPjBvavAyuq6vGhvsuS3AOcDZwEfKntXwHsBbyjqtYDJLkSuAu4NMmbq6pGxr+vqv7tGPMYe+wkBwCnA2uq6oODAZLcD3wR+DBw9Vg/vSRJkjRHxloSU1WTI2F94Jq2fQtAu9TkA8ANg0Dd7v8U8GVgX+DgrmMkmZdkwVRz2IaxjwMCXDwy1OXAJuD4qY4lSZIk9cX23nT6urbd0LYHArsD3+uovbltuwL779OE6CeT/EOSS5K8eqRmpmMfDLwA3DJcWFWbgfVTzEOSJEnqlXGXxLxIkl2B5TTryQdLS/Zu24c7dhn0LR7pvwX4GnAv8Crg/cBpwG8lOay9gr4tY+8NbKyqZ6eoPyzJvKp6rmO7JEmS1AvbHNhplposBT5dVT9q+/Zo266QvHmkBoCqeudI3ZVJfgD8K+Bftu22jL3HFLWj9S8K7EmWAcsAlixZMsUQkiRJ0uzbpiUxSS6guQq+qqpWDG3a1La7d+w2f6RmOn9GE6SP3o6xN01Ru9W5VNWqqpqoqolFixaNMV1JkiRpdsw4sCc5DzgHuAL4+MjmR9p2dNnLcF/XkpYtVNXz7VgLt2PsR4CFSbpC+2Ka5TIuh5EkSVKvzSiwJzkXOBe4Eji54/GMd9AsQzm0Y/elbTs5xnHm09zQumGoe6Zjf5/m5zukY+yDxpmHJEmSNNfGDuxJlgPnAVcBH+166VB7g+ha4D1J3jq07wLgZOAehp7akuTXpzjcBTTr69du69g0j5ws4IyRsU+hWbu+erqfV5IkSeqDsW46TXIq8BngQeB64CNJhks2VNV17ddnAe8FvpNkJfAETUheDBw9clX+nCRLgb9tx15A85SYw4H/BFwyMpWxx66qO5JcCpyWZA3wLX75ptN1+NIkSZIk7QTGfUrM4JnlS4CvdmxfB1wHUFX3JnkX8HngU8A84DbgfVV1/ch+NwC/AfwR8OvAP9JcKT8b+EL7zPRfmOHY0Fxdf4DmiS9HAxtpfglY3vUXAkmSJKlv8uJl6Bo2MTFRk5Mud5ckSdLsSXJrVU10bdveN51KkiRJmkUGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPXYWIE9yb5Jzk9yc5JHkzyZZH2Ss5Ps2VG/X5JrkzyW5OkkNyY5YgeMe16SmuLzyY76XZKcmeTuJJuTPJTkoq6xJUmSpD7abcy6jwGnAt8EVgPPA4cDnwWOTbK0qp4BSLIPcBPwc+BC4HHgFODbSY6qquu3ZdwRZwIbR/pu7ahbCXwC+AZwEbB/+/3bkhxZVS+M+fNLkiRJc2LcwP51YEVVPT7Ud1mSe4CzgZOAL7X9K4C9gHdU1XqAJFcCdwGXJnlzVdU2jDvs2qp6YLoJJzkAOB1YU1UfHOq/H/gi8GHg6q383JIkSdKcGmtJTFVNjoTqgWva9i0A7VKTDwA3DMJ6u/9TwJeBfYGDZzpulySvSjLdLxzHAQEuHum/HNgEHD/NvpIkSVIvbO9Np69r2w1teyCwO/C9jtqb2/bgjm1bG3fUD2iW2mxOclOSozpqDgZeAG4Z7qyqzcD6MechSZIkzaltDuxJdgWW06xVHywt2bttH+7YZdC3eBvGHfgZsIpmqcsxwFnAG4C/TnLiSO3ewMaqenaKuSxMMm+6uUiSJElzbdw17F0uBpYCn66qH7V9e7RtV0jePFIzk3EBqKqLR4uTfAW4E1iZ5Ovt8pvBcbrmMTqX5zrGXAYsA1iyZMlWpitJkiTNnm26wp7kAuA0YFVVrRjatKltd+/Ybf5IzUzGnVJV/QS4jOZG18NG5tI1j63OpapWVdVEVU0sWrRonGlIkiRJs2LGgT3JecA5wBXAx0c2P9K2XcteBn1dy2W2Nu7WPNC2C0fmsjBJV2hfTLNc5kVX1yVJkqQ+mVFgT3IucC5wJXDy0OMZB+6gWYZyaMfuS9t2chvG3Zo3te3wTarfp/n5Dhk51nzgoK55SJIkSX0zdmBPshw4D7gK+GjXS4fa9eNrgfckeevQvguAk4F7GHlqyzjjtnW7JXl1R//rgT8GfkLzwqaBa4ACzhjZ5RSateurp/xhJUmSpJ4Y66bTJKcCnwEeBK4HPpJkuGRDVV3Xfn0W8F7gO0lWAk/QhOTFwNHDV89nOO4C4P4k1wJ/BzwG7Efzi8AC4Ljht6JW1R1JLgVOS7IG+Ba/fNPpOnxpkiRJknYC4z4lZvDM8iXAVzu2rwOuA6iqe5O8C/g88ClgHnAb8L6qun5bxwWeAf4SeCfwuzQhfSNN0L+wqm7p2P8MmvXty4Cj2/pLgOVTXcmXJEmS+iQzXy7+yjIxMVGTky53lyRJ0uxJcmtVTXRt2943nUqSJEmaRQZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9dhYgT3JvknOT3JzkkeTPJlkfZKzk+zZUb9fkmuTPJbk6SQ3JjliirF3SXJmkruTbE7yUJKLusad7bElSZKkvhn3CvvHgDOBvwfOB/4E+BHwWeCmJL8yKEyyD3ATcChwYVu7APh2kiM7xl4JfAH4IXA68DXgE8DaJFvMbzbHliRJkvpotzHrvg6sqKrHh/ouS3IPcDZwEvCltn8FsBfwjqpaD5DkSuAu4NIkb66qavsPoAnSa6rqg4OBk9wPfBH4MHD10DFnc2xJkiSpd8a6ylxVkyNhfeCatn0LQLvU5APADYNA3e7/FPBlYF/g4KH9jwMCXDwy7uXAJuD4Qcdsji1JkiT11fYuC3ld225o2wOB3YHvddTe3LbDofpg4AXgluHCqtoMrB+pnc2xJUmSpF4ad0nMiyTZFVgO/JxfLi3Zu20f7thl0Ld4qG9vYGNVPTtF/WFJ5lXVc7M8dq98Zu1d/PCRJ+Z6GpIkSa84v7H3qzj3dw6Y62lsYXuusF8MLAWWV9WP2r492rYrJG8eqRl83VXbVT+bY28hybIkk0kmH3300SmGkCRJkmbfNl1hT3IBcBqwqqpWDG3a1La7d+w2f6Rm8PU/meIwo/WzOfYWqmoVsApgYmKiphhj1vTttzpJkiTNnRlfYU9yHnAOcAXw8ZHNj7TtYl5s0De8pOURYGGSrhC+mGZJy3NDtbM1tiRJktRLMwrsSc4FzgWuBE4ePEJxyB00y1AO7dh9adtODvV9v53DISPHmQ8cNFI7m2NLkiRJvTR2YE+yHDgPuAr4aFW9MFrTPmJxLfCeJG8d2ncBcDJwD1s+teUaoIAzRoY6hWZ9+eqXYmxJkiSpr8Zaw57kVOAzwIPA9cBHkgyXbKiq69qvzwLeC3wnyUrgCZqQvBg4eviqfFXdkeRS4LQka4BvAfvTvI10HS9+sdFsji1JkiT1zrg3nQ6eWb4E+GrH9nXAdQBVdW+SdwGfBz4FzANuA95XVdd37HsG8ACwDDga2AhcQvP0mS2u4s/m2JIkSVIf5cXL0DVsYmKiJidd7i5JkqTZk+TWqpro2ra9bzqVJEmSNIsM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeqxsQJ7krOSfC3JfUkqyQNbqf9QkpuSPJ3kySQ3Jnl/R9157XhTfZ6fQf0nO8bfJcmZSe5OsjnJQ0kuSrLnOD+3JEmSNNd2G7Puc8BPgduAvaYrTPKnwOeB24HlQAHHA3+V5ISqWj1Uvga4t2OYA4E/AdZOcZgzgY0jfbd21K0EPgF8A7gI2L/9/m1JjqyqF6b7WSRJkqS5Nm5g36eq7gNIciewoKsoyWuA84E7gXdW1fNt/yU0Yf+SJGur6gmAqvoB8IOOcf68/fIvppjPtVX1wHQTTnIAcDqwpqo+ONR/P/BF4MPA1dONIUmSJM21sZbEDML6GA4D5gGrB2G93f95mnD8q8Ax0w2QZA+aMP0w8DfT1L0qyXS/cBwHBLh4pP9yYBPNVX9JkiSp13b0Tae7t+2mjm2DvqVbGeNY4FXAFVX1j1PU/AB4HNjcrpU/qqPmYOAF4JbhzqraDKxvt0uSJEm9tqMD+11te0THtsPb9vVbGeMkmnXvX+nY9jNgFc1Sl2OAs4A3AH+d5MSR2r2BjVX1bMc4DwMLk8zbylwkSZKkOTXuGvaxVNUdSa4DjklyIXBFu+lEYHAVfI+p9k+yH/CbwH+oqvs7xr+4Y5+v0KyZX5nk61X11NBxusI6wOahmuc6xlwGLANYsmTJVNOVJEmSZt1sPIf9D2ie/vJJ4Ift51jg1Hb7E9Pse1Lbfnncg1XVT4DLaJ5ec9jQpk38conOqPlDNV1jrqqqiaqaWLRo0bhTkSRJkna4HR7Yq+qx9qksrwXeDbwd2Ad4pC25u2u/9gbSP6R5fOQ3ZnjYB9p24VDfIzTLXrpC+2Ka5TIvurouSZIk9cmsvem0qjZU1Y1VdXv7vPPBi5O+NcUuvwO8BrhqinXn03lT224Y6vs+zc93yHBhkvnAQcDkDI8hSZIkveRmLbAPSzIBnAysq6rvTlE2WA7T+ez1JLsleXVH/+uBPwZ+Atw0tOkamptXzxjZ5RSateurkSRJknpurJtOk5xA8zQWgEXAvCTntN//uKquGqq9gOaK9y00j158O/AxmieznDDF+HsD7wNuqao7ppjGAuD+JNcCfwc8BuxH84vAAuC4qnpmUNzeAHspcFqSNTRX9gdvOl2HL02SJEnSTmDcp8ScBPzWSN8FbbsOuGqo/3bgSOC3aa5kP0jzZtEVVfWzKcY/EdiV6W82fQb4S+CdwO/ShPSNwPXAhVV1S8c+Z9Csb18GHN3WXwIsb5fpSJIkSb2WqprrOfTaxMRETU663F2SJEmzJ8mtVTXRte0lWcMuSZIkadsY2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjBnZJkiSpxwzskiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjBnZJkiSpxwzskiRJUo8Z2CVJkqQeM7BLkiRJPWZglyRJknrMwC5JkiT1mIFdkiRJ6jEDuyRJktRjYwX2JGcl+VqS+5JUkge2Uv+hJDcleTrJk0luTPL+KWpris9TU9Tvl+TaJI+149+Y5IgpandJcmaSu5NsTvJQkouS7DnOzy1JkiTNtd3GrPsc8FPgNmCv6QqT/CnweeB2YDlQwPHAXyU5oapWd+x2I7BqpO/5jrH3AW4Cfg5cCDwOnAJ8O8lRVXX9yC4rgU8A3wAuAvZvv39bkiOr6oXpfhZJkiRpro0b2PepqvsAktwJLOgqSvIa4HzgTuCdVfV8238JTdi/JMnaqnpiZNf7qurfjjGPFTS/MLyjqta3Y18J3AVcmuTNVVVt/wHA6cCaqvrg0BzvB74IfBi4eoxjSpIkSXNmrCUxg7A+hsOAecDqQVhv93+eJhz/KnBM145J5iXp/EWg3b4n8AHghkFYb8d+CvgysC9w8NAuxwEBLh4Z6nJgE81Vf0mSJKnXdvRNp7u37aaObYO+pR3bfr/d/mSSf0hySZJXj9Qc2I7/vY79b27b4cB+MPACcMtwYVVtBtaP1EqSJEm9tKMD+11t23UT6OFt+/qR/luA82hC+x8B/zdwGnDjyBX3vdv24Y6xB32LR+o3VtWzU9QvTDKvY5skSZLUG+OuYR9LVd2R5DrgmCQXAle0m04Ejmq/3mNkn3eODHNlkh8A/wr4l207vF9XAN/cMfYeU9SO1j83ujHJMmAZwJIlS6YYQpIkSZp9s/Ec9j8A1gCfBH7Yfo4FTm23j95w2uXPaIL00UN9gyU1u7+4nPkjNYOvu2qnqv+FqlpVVRNVNbFo0aIxpitJkiTNjh0e2KvqsfapLK8F3g28HdgHeKQtuXuMMZ5v6xcOdQ/2X/ziPX7RN7xc5hGaZS9doX0xzXKZF11dlyRJkvpk1t50WlUbqurGqrq9fd754MVJ39ravknmA68DNgx130GzxOXQjl0GN7JODvV9n+bnO6Rj7INGaiVJkqRemrXAPizJBHAysK6qvjvU/+tT7HIBzfr6tYOO9vGNa4H3JHnr0BgL2rHvYcsnwlxD89KmM0bGPoVm7XrXC5wkSZKkXhnrptMkJwBvaL9dBMxLck77/Y+r6qqh2guAN9GE58dplsR8jGa5ygkjQ5+TZCnwt8CDNC9kej/NE2X+E3DJSP1ZwHuB7yRZSbMe/hSaJS5HD16aBL+4AfZS4LQka2iu7A/edLoOX5okSZKkncC4T4k5Cfitkb4L2nYdcNVQ/+3AkcBv01zJfpDmzaIrqupnI2PcAPwGzeMcfx34R5or5WcDX2ifmf4LVXVvkncBnwc+RfOSptuA91XV9R3zPgN4gOaJL0cDG2l+CVjeLtORJEmSei1DF6XVYWJioiYnXe4uSZKk2ZPk1qqa6Nr2kqxhlyRJkrRtDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqsbECe5KzknwtyX1JKskDW6n/UJKbkjyd5MkkNyZ5f0fdvknOT3Jzkkfb2vVJzk6yZ0f9ee3xuz6f7KjfJcmZSe5OsjnJQ0ku6hpbkiRJ6qPdxqz7HPBT4DZgr+kKk/wp8HngdmA5UMDxwF8lOaGqVg+Vfww4FfgmsBp4Hjgc+CxwbJKlVfVMx2HOBDaO9N3aUbcS+ATwDeAiYP/2+7clObKqXpjuZ5EkSZLm2riBfZ+qug8gyZ3Agq6iJK8BzgfuBN5ZVc+3/ZfQhP1LkqytqifaXb4OrKiqx4eGuSzJPcDZwEnAlzoOdW1VPTDdhJMcAJwOrKmqDw713w98EfgwcPW0P7UkSZI0x8ZaEjMI62M4DJgHrB6E9Xb/52nC8a8Cxwz1T46E9YFr2vYtUx0oyauSTPcLx3FAgItH+i8HNtFc9ZckSZJ6bUffdLp7227q2DboWzrGOK9r2w1TbP8B8DiwuV0rf1RHzcHAC8Atw51VtRlY326XJEmSem1HB/a72vaIjm2Ht+3rpxsgya40a99/zouXrPwMWEWz1OUY4CzgDcBfJzlxpHZvYGNVPdtxmIeBhUnmTTcXSZIkaa6Nu4Z9LFV1R5LrgGOSXAhc0W46ERhcBd9jK8NcTHMV/tNV9aOR8S8eLU7yFZo18yuTfL2qnho6TldYB9g8VPNcx5jLgGUAS5Ys2cp0JUmSpNkzG89h/wNgDfBJ4Ift51iap8EAPDHFfiS5ADgNWFVVK8Y5WFX9BLiM5uk1hw1t2sQvl+iMmj9U0zXmqqqaqKqJRYsWjTMNSZIkaVbs8MBeVY+1T2V5LfBu4O3APsAjbcndXfslOQ84h+aq/MdneNgH2nbhUN8jNMteukL7YprlMi+6ui5JkiT1yay96bSqNlTVjVV1e/u888GLk741WpvkXOBc4Erg5KqqGR7uTW07fJPq92l+vkNGjjUfOAiYnOExJEmSpJfcrAX2YUkmgJOBdVX13ZFty4HzgKuAj071MqMkuyV5dUf/64E/Bn4C3DS06RqalzadMbLLKTRr11cjSZIk9dxYN50mOYHmaSwAi4B5Sc5pv/9xVV01VHsBzRXvW2gevfh2mjeaPgycMDLuqcBngAeB64GPJBku2VBV17VfLwDuT3It8HfAY8B+NL8ILACOG34ransD7KXAaUnW0FzZH7zpdB2+NEmSJEk7gXGfEnMS8FsjfRe07Tqaq+MDtwNHAr9NcyX7QZo3i66oqp+NjDF4FvoS4Ksdx10HDAL7M8BfAu8EfpcmpG+kCfoXVtUtHfufQbO+fRlwdFt/CbB8qiv5kiRJUp9k5svFX1kmJiZqctLl7pIkSZo9SW6tqomubS/JGnZJkiRJ28bALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9ZmCXJEmSeszALkmSJPWYgV2SJEnqMQO7JEmS1GMGdkmSJKnHDOySJElSjxnYJUmSpB4zsEuSJEk9NlZgT3JWkq8luS9JJXlgK/UfSnJTkqeTPJnkxiTvn6J2lyRnJrk7yeYkDyW5KMmeU9Tvl+TaJI+149+Y5IgdMbYkSZLUN+NeYf8ccATw98Bj0xUm+VPg3wPzgeXAucCewF8l+R86dlkJfAH4IXA68DXgE8DaJFvML8k+wE3AocCFwJ8AC4BvJzlye8aWJEmS+mi3Mev2qar7AJLcSROSXyTJa4DzgTuBd1bV823/JcBtwCVJ1lbVE23/ATRBek1VfXBonPuBLwIfBq4eOsQKYC/gHVW1vq29ErgLuDTJm6uqtnFsSZIkqXfGuso8COtjOAyYB6wehPV2/+dpwvGvAscM1R8HBLh4ZJzLgU3A8YOOdhnLB4AbBmG9Hfsp4MvAvsDB2zK2JEmS1Fc7elnI7m27qWPboG/pUN/BwAvALcOFVbUZWM+WAfzAdvzvdYx989B42zK2JEmS1Es7OrDf1bZdN4Ee3ravH+rbG9hYVc921D8MLEwyb6h20N9VC7B4G8feQpJlSSaTTD766KNdJZIkSdJLYocG9qq6A7gOOCbJhUn2bz//G3BUW7bH0C57AF2BGmDzSP2g7aofrZ3p2FuoqlVVNVFVE4sWLZpiCEmSJGn2zcaTUv4AWAN8kubpLD8EjgVObbc/MVS7iV8uoxk1f6hmuO2qH62d6diSJElSL+3wwF5Vj7VPZXkt8G7g7cA+wCNtyd1D5Y/QLE3pCtaLaZa0PDdUO+jvqoUtl8vMZGxJkiSpl2btWeRVtaGqbqyq26vqBWDw4qRvDZV9v53DIcP7JpkPHARMDnXfQbPE5dCOww1uZB2un8nYkiRJUi+9JC8PSjIBnAysq6rvDm26BijgjJFdTqFZX7560NE+vnEt8J4kbx0ae0E79j1s+USYsceWJEmS+mqsFyclOQF4Q/vtImBeknPa739cVVcN1V4AvIkmPD9OsyTmYzTLVU4YHreq7khyKXBakjU0V9/3p3kb6Tpe/GKjs4D3At9JspJmPfwpNEtcjh68NGkbx5YkSZJ6Z9w3nZ4E/NZI3wVtuw64aqj/duBI4LdprmQ/SPNm0RVV9bOOsc8AHgCWAUcDG4FLgOXtUppfqKp7k7wL+DzwKZqXNN0GvK+qrt+esSVJkqQ+ytBFaXWYmJioyUmXu0uSJGn2JLm1qia6tr0ka9glSZIkbRsDuyRJktRjBnZJkiSpxwzskiRJUo8Z2CVJkqQeM7BLkiRJPeZjHbciyaPAj+fg0Atpnhuvlz/P9SuH5/qVw3P9yuG5fuWY7XP9hqpa1LXBwN5TSSanehanXl48168cnutXDs/1K4fn+pVjLs+1S2IkSZKkHjOwS5IkST1mYO+vVXM9Ab1kPNevHJ7rVw7P9SuH5/qVY87OtWvYJUmSpB7zCrskSZLUYwZ2SZIkqccM7D2SZJckZya5O8nmJA8luSjJnnM9N81ckn2TnJ/k5iSPJnkyyfokZ3ed0yT7Jbk2yWNJnk5yY5Ij5mLu2n5J9khyf5JK8qWO7Z7vnViSX0vyvye5t/3v9aNJ/jbJfz9S53neiSVZkOTTSe5o/xu+MclNSU5MkpFaz/VOIMlZSb6W5L72v88PbKV+7PM6mzlut+0dQDvUSuATwDeAi4D92+/fluTIqnphLienGfsYcCrwTWA18DxwOPBZ4NgkS6vqGYAk+wA3AT8HLgQeB04Bvp3kqKq6fg7mr+1zPs1LNl7E871zS/IG4AZgAfAXwH8GXg0cCCweqvM878SS7AL8X8BhwFeBS4A9gOOAK2j+P/pP21rP9c7jc8BPgduAvaYr3IbzOns5rqr89OADHAC8APzlSP/pQAEfmes5+pnxOZ0AXt3R/9n2nJ421PfvgX8EDhrqW0Dzlt0f0d4g7mfn+ABvb/8D/z+15/pLI9s93zvxB7gReAh47VbqPM878Qc4tP33u3Kkfx5wH/Azz/XO9wH+u6Gv7wQemKZ27PM62znOJTH9cRwQ4OKR/suBTcDxL/WEtH2qarKqHu/YdE3bvgWg/VPZB4Abqmr90P5PAV8G9gUOnt3ZakdJsivNv9u/AdZ0bPd878SSvBv4TeDCqvovSf6bJHt01Hmed36vattHhjur6jma19M/DZ7rnU1V3TdO3Tac11nNcQb2/jiY5jezW4Y7q2ozsB7/sb+cvK5tN7TtgcDuwPc6am9uW8//zuNM4M3AaVNs93zv3N7ftg8mWQs8Azyd5D8nGf4/ZM/zzu8W4GfA/5LkQ0mWtOuZVwDvAM5r6zzXL08zPa+zmuMM7P2xN7Cxqp7t2PYwsDDJvJd4TtrB2quvy2mWS1zddu/dtg937DLoW9yxTT2T5J8CnwHOr6oHpijzfO/c9mvby4FfA/4IOAl4DrgqyUfb7Z7nnVxVPUZzhfWnNEsjfgzcTXNv0ger6vK21HP98jTT8zqrOc6bTvtjD6DrJANsHqp57qWZjmbJxcBS4NNV9aO2b/Dn9K7zv3mkRv32r4H7gS9MU+P53rn9t237JHB4uzyCJN+gWdf8uSRfxfP8cvEUzTrnb9LcfPhrNIH96iTHVNV1eK5frmZ6Xmc1xxnY+2MT8E+m2DZ/qEY7qSQX0CyTWFVVK4Y2Dc7r7h27ee53Eu1yiN8G3l1Vz09T6vneuT3Ttv9uENahuRqb5JvAH9Jchfc87+SS/HOakH5mVV021P/vaEL85e1TRDzXL08zPa+zmuNcEtMfj9D8uaTrfxiLaf7M4tX1nVSS84BzaB4F9vGRzYMbmrr+ZDro6/qTnHqi/Xf7BeBbwH9N8s+S/DPgDW3Jq9u+vfB87+z+v7b9rx3b/kvb/iqe55eDM2mC1teGO6tqE/DXNP++34jn+uVqpud1VnOcgb0/vk9zPg4Z7kwyHzgImJyDOWkHSHIucC5wJXBytc95GnIHzZ/RDu3YfWnbev777VeARcDRwD1Dnxva7ce335+M53tnN7ih7HUd2wZ9/4Dn+eVgEMp27di221DruX55mul5ndUcZ2Dvj2tontN5xkj/KTRrnla/1BPS9kuynOZJAlcBH62Olya0j4haC7wnyVuH9l1AE/DuYeSuc/XO08CHOj7/Y7v9b9rvv+n53uldS7N+/fj2nAGQ5LXA7wL3VNW9nueXhR+27YnDne1fyo4BHgP+3nP98rQN53VWc1xefLFPcyXJJTRrnL9B86f1wRuy/iNwRFfYU38lORX4EvAg8L/SPO5p2Ib2hiXa5RO30LwNdSXwBM0/8n8OHF1V336p5q0dJ8kbaW5CvbSqThvq93zvxJIsA/4cuAv4Cs2LdP4YeC3wL6rqO22d53kn1r7R9jaaJU6raf6/+NdozuEbgVOr6v9oaz3XO4kkJ/DL5Yqn0/z7vaj9/sdVddVQ7YzO66zmuLl+45SfLd6GtSvwP9O8PetZmrVRXwAWzPXc/GzT+fw3NL9tT/W5YaR+f+D/pHnu7ybgu8CRc/1z+Nmu/w28kY43nXq+d/4P8Hs0z2J+muaK+3eAd3meX14fYB/gqzT3LjxPE9j+H+D3PNc754dmqeJY/7880/M6mznOK+ySJElSj7mGXZIkSeoxA7skSZLUYwZ2SZIkqccM7JIkSVKPGdglSZKkHjOwS5IkST1mYJckSZJ6zMAuSZIk9ZiBXZIkSeoxA7skSZLUY/8/todZhkCIfFMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lengths[-100:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f49aa3f4b80>"
      ]
     },
     "execution_count": 368,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(keep_probs[:1000:10], aspect=\"auto\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "on_prob = scipy.ndimage.filters.gaussian_filter(np.asarray(light_states).astype(float), 100)\n",
    "plt.plot(on_prob, label=\"Light 'On' Probability\")\n",
    "plt.plot(calc_entropy(on_prob), label=\"Naive Entropy [bits]\")\n",
    "\n",
    "plt.legend(loc=4)\n",
    "plt.title(\"Example Trajectory\")\n",
    "plt.xlabel(\"Days\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f49aac7f3a0>]"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.max(cnts, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 1, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 2, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 1, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 0]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 1, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        1, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 1, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 2, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 4, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 1, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 1, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 0, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 0, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 3, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 2, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 1, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 1, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 0, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 2,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 0, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 1, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 1, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 1, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 4, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 1,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 2, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 2, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 2, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 2, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 2, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 2, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 0, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 1, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 1, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 1, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 1, 0, 4, 0, 0, 1, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 4, 2, 1, 0, 1, 1, 1, 1, 1, 0, 2, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 4, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 4, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 1, 1, 1, 0, 4, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 4, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 1, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 1, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 0, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 1, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 0, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 4, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 1, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 0, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 4, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 1, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        1, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 2, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 1]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 1, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,\n",
       "        1, 5, 1, 0, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 1, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 1,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 1, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 3, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        0, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 1, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 0, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 4, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 4, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 3, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 1, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 1, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 1, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 1, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 3, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 1, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 0, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 2,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 5, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 2, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 0, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 0, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 3, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 0, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 5, 2, 1, 0, 3, 2, 1, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 5, 2, 1, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 5, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 0, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 5, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 5, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 5, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 1, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 0, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        1, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 1, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 1, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 1, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 2, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        1, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 1, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 1, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        1, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 4, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 6, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 1, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 1, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 2, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 6, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 5, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 5, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 5, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 2, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 1, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 3, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 4, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 2, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 2, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 1, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 0, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 2, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 1, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 4, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 2, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 3, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 0, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 0, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 1, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 0, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 2, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 1, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 2, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 4, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 1, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 1, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 1, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 1, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 4, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 2, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 1, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 5, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 1, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 3, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 2, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 6, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 3, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 0, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 1, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 5, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 2, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 0, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 2, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 5, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 1, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 1, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 4, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 2, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 1, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 0,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 1, 1, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 3, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        0, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 0, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 1, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 4, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 0, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 2, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 0, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 1, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 0, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 1, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 2, 0, 1,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 2, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 2, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 2, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 1, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 1, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 0, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 4, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 1, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 0, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 0,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 0,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 2, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 1, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 1, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 1, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 1, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 0, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 1, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 1, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 5, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 1, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 0, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 3, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([0, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 5, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 2,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 1, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 4, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 1, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 1,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 1, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 0, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 0, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 1, 1, 5, 5, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 0, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " array([1, 1, 0, 1, 0, 2, 1, 0, 1, 1, 5, 4, 0, 0, 2, 0, 3, 1, 2, 0, 0, 0,\n",
       "        1, 1, 0, 0, 0, 1, 6, 2, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 3, 1, 0, 2,\n",
       "        0, 5, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 1, 0, 1, 0, 3,\n",
       "        0, 0, 0, 1, 4, 0, 0, 0, 2, 3, 5, 0, 0, 0, 1, 1, 0, 1, 0, 1, 3, 1,\n",
       "        0, 1, 1, 0, 2, 0, 0, 0, 4, 0, 2, 0]),\n",
       " ...]"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cnts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f49ac908ee0>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.array(cnts[:1000]), aspect=\"auto\", interpolation=\"nearest\")\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f49aca151f0>]"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(pamts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(cnts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20000"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(cnts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([34, 49, 11,  4,  1,  0,  0,  0,  0,  0,  0,  0,  1])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bincount(cnts[100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cnts[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 99])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bincount(cnts[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_\n",
    "light_state = False\n",
    "    current_counts = np.ones(N_members, dtype=int)\n",
    "    \n",
    "    light_history = []\n",
    "    member_history = []\n",
    "    \n",
    "    carry_amt = 0\n",
    "    \n",
    "    for day_idx in range(max_days):\n",
    "        ci = np.random.randint(N_members)\n",
    "        if light_state:\n",
    "            current_counts[ci] += carry_amt \n",
    "\n",
    "        available = current_counts[ci]\n",
    "        \n",
    "        if available >= N_members:\n",
    "            break\n",
    "        \n",
    "        carry_amt = n_transfer_fn(day_idx)\n",
    "        \n",
    "        light_state = False\n",
    "        if available >= carry_amt:\n",
    "            #transfer_prob = 0.5*carry_amt/available\n",
    "            transfer_prob = 1.0\n",
    "            if ci == 0:\n",
    "                transfer_prob = 0.0\n",
    "            leaves_light_on = np.random.random() < transfer_prob\n",
    "            if leaves_light_on:\n",
    "                light_state = leaves_light_on\n",
    "                current_counts[ci] -= carry_amt\n",
    "        \n",
    "        light_history.append(light_state)\n",
    "        member_history.append(ci)\n",
    "    \n",
    "    return np.array(light_history), np.array(member_history), current_counts"
   ]
  }
 ],
 "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.8.8"
  },
  "nikola": {
   "author": "Tim Anderton",
   "category": "",
   "date": "2021-01-10 10:59:25 UTC-07:00",
   "description": "",
   "link": "",
   "slug": "lightbulb-codes",
   "tags": "",
   "title": "Lightbulb Codes",
   "type": "text"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}