diff --git a/.gitignore b/.gitignore
index 8cdedd3..40dc2cc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -95,3 +95,6 @@ ENV/
 
 # Rope project settings
 .ropeproject
+
+# TEMP files
+temp_*
diff --git a/README.md b/README.md
index 8c472f4..7774da2 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,15 @@ CANAlization: Control & Redundancy in Boolean Networks
 
 This package implements a series of methods used to study control, canalization and redundancy in Boolean Networks.
 
+Citation:
+-------------
+
+If you use `cana` in your research, please cite us and check out our related papers below! 
+
+- A.M. Marcus, J.C. Rozum, H. Sizek, L.M. Rocha [2025]. "[CANA v1.0.0: efficient quantification of canalization in automata networks](https://doi.org/10.1093/bioinformatics/btaf461)". *Bioinformatics*. btaf461. doi: 10.1093/bioinformatics/btaf461
+
+
+
 Installation:
 -------------
 
@@ -34,6 +43,8 @@ The full documentation can be found at: [casci-lab.github.io/CANA/](https://casc
 Papers:
 ---------
 
+- A.M. Marcus, J.C. Rozum, H. Sizek, L.M. Rocha [2025]. "[CANA v1.0.0: efficient quantification of canalization in automata networks](https://doi.org/10.1093/bioinformatics/btaf461)". *Bioinformatics*. btaf461. doi: 10.1093/bioinformatics/btaf461
+
 - A.J. Gates, R.B. Correia, X. Wang, L.M. Rocha [2021]. "[The effective graph reveals redundancy, canalization, and control pathways in biochemical regulation and signaling](https://doi.org/10.1073/pnas.2022598118)". *Proceedings of the National Academy of Sciences (PNAS)*. 118(**12**). doi: 10.1073/pnas.20225981186
 
 - R.B. Correia, A.J. Gates, X. Wang, L.M. Rocha [2018]. "[CANA: A python package for quantifying control and canalization in Boolean Networks](https://www.informatics.indiana.edu/rocha/publications/FSB18.php)". *Frontiers in Physiology*. **9**: 1046. doi: 10.3389/fphys.2018.01046
diff --git a/automata/automata.ipynb b/automata/automata.ipynb
new file mode 100644
index 0000000..93acf7d
--- /dev/null
+++ b/automata/automata.ipynb
@@ -0,0 +1,956 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cana.drawing.schema_vis import plot_schemata\n",
+    "from cana.drawing.plot_look_up_table import plot_look_up_table\n",
+    "from automata.automata_rules import automata_output_list, autoschemata\n",
+    "from automata.schema_search_tools import (\n",
+    "    annihilation_generation_rules,\n",
+    "    maintenance_rules,\n",
+    "    # plot_hist,\n",
+    "    # plot_scatter,\n",
+    "    collect_data_from_generator,\n",
+    "    min_max_and_parent_rule_values,\n",
+    "    shuffle_and_generate,\n",
+    "    shuffle_wildcards_in_schemata,\n",
+    ")\n",
+    "\n",
+    "from cana.boolean_node import BooleanNode\n",
+    "import pandas as pd\n",
+    "import random\n",
+    "import matplotlib.pyplot as plt\n",
+    "from concurrent.futures import ProcessPoolExecutor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## automata binary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "automata = {\n",
+    "    \"GKL_BIN\": 0b00000000_01011111_00000000_01011111_00000000_01011111_00000000_01011111_00000000_01011111_11111111_01011111_00000000_01011111_11111111_01011111,\n",
+    "    \"GKL_STR\": \"!x_{c}&x_{l1}&x_{l3} | x_{r3}&x_{c} | x_{r1}&x_{c}\",\n",
+    "    \"GP_BIN\": 0b00000101_00000000_01010101_00000101_00000101_00000000_01010101_00000101_01010101_11111111_01010101_11111111_01010101_11111111_01010101_11111111,\n",
+    "    \"GP_STR\": \"x_{r3}&x_{r1}&!x_{c} | x_{r3}&x_{r1}&x_{l1} | x_{r3}&!x_{c}&x_{l1} | x_{r3}&x_{l3} | x_{c}&x_{l3}\",\n",
+    "    \"GEP_1_BIN\": 0b00010001_00000000_01010101_00000000_00010001_00001111_01010101_00001111_00010001_11111111_01010101_11111111_00010001_11111111_01010101_11111111,\n",
+    "    \"GEP_1_STR\": \"x_{r3}&x_{r2}&!x_{c} | x_{r3}&!x_{c}&x_{l1} | x_{r1}&x_{c}&x_{l2} | x_{c}&x_{l3}\",\n",
+    "    \"GEP_2_BIN\": 0b00000000_01010101_00000000_01110111_00000000_01010101_00000000_01110111_00001111_01010101_00001111_01110111_11111111_01010101_11111111_01110111,\n",
+    "    \"GEP_2_STR\": \"x_{r2}&x_{c}&x_{l1} | x_{r1}&!x_{c}&x_{l3} | !x_{c}&x_{l2}&x_{l3} | x_{r3}&x_{c}\",\n",
+    "    \"Das_BIN\": 0b00000111_00000000_00000111_11111111_00001111_00000000_00001111_11111111_00001111_00000000_00000111_11111111_00001111_00110001_00001111_11111111,\n",
+    "    \"Das_STR\": \"x_{r3}&x_{r2}&x_{r1}&x_{l2}&x_{l3} | x_{r2}&!x_{r1}&x_{c}&x_{l2}&x_{l3} | x_{r1}&!x_{c}&!x_{l1}&x_{l3} | x_{r3}&x_{r1}&!x_{c} | x_{r2}&x_{r1}&!x_{c} | x_{r1}&!x_{c}&x_{l2} | x_{c}&x_{l1}\",\n",
+    "    \"Davis_BIN\": 0b00000000_00101111_00000011_01011111_00000000_00011111_11001111_00011111_00000000_00101111_11111100_01011111_00000000_00011111_11111111_00011111,\n",
+    "    \"Davis_STR\": \"!x_{r3}&x_{r2}&x_{c}&!x_{l1}&!x_{l2} | x_{r3}&x_{c}&x_{l1}&!x_{l2} | x_{r3}&x_{r2}&x_{c}&x_{l2} | !x_{r2}&!x_{c}&x_{l1}&x_{l2} | x_{r2}&x_{r1}&x_{l1}&!x_{l3} | !x_{r2}&x_{r1}&x_{l1}&x_{l3} | !x_{r1}&!x_{c}&x_{l1}&x_{l3} | x_{r1}&x_{l1}&x_{l2} | x_{r1}&x_{c}\",\n",
+    "    \"ABK_BIN\": 0b00000101_00000000_01010101_00000101_00000101_00000000_01010101_00000101_01010101_11111111_01010101_11111111_01010101_11111111_01010101_11111111,\n",
+    "    \"ABK_STR\": \"x_{r3}&x_{r1}&!x_{c} | x_{r3}&x_{r1}&x_{l1} | x_{r3}&!x_{c}&x_{l1} | x_{r3}&x_{l3} | x_{c}&x_{l3}\",\n",
+    "    \"DMC_BIN\": 0b00000101_00000100_00000101_10000111_00000101_00000000_00001111_01110111_00000011_01110111_01010101_10000011_01111011_11111111_10110111_01111111,\n",
+    "    \"DMC_STR\": \"!x_{r3}&!x_{r2}&!x_{r1}&x_{c}&x_{l1}&!x_{l2} | !x_{r3}&!x_{r1}&!x_{c}&x_{l1}&x_{l2}&x_{l3} | x_{r3}&!x_{r2}&x_{r1}&!x_{l2}&!x_{l3} | x_{r1}&!x_{c}&x_{l1}&x_{l2}&!x_{l3} | x_{r3}&!x_{c}&x_{l1}&!x_{l2}&x_{l3} | x_{r3}&!x_{r1}&!x_{l1}&x_{l2}&x_{l3} | !x_{r3}&x_{r1}&!x_{l1}&x_{l2}&x_{l3} | x_{r2}&x_{r1}&x_{c}&x_{l1} | x_{r3}&x_{r1}&x_{l1}&x_{l2} | x_{r3}&x_{c}&x_{l1}&x_{l2} | x_{r2}&x_{c}&x_{l1}&x_{l2} | x_{r3}&x_{r1}&!x_{c}&!x_{l3} | x_{r2}&x_{r1}&!x_{l1}&x_{l3} | x_{r3}&x_{c}&!x_{l1}&x_{l3} | x_{r2}&x_{c}&!x_{l1}&x_{l3} | x_{r1}&x_{c}&x_{l2}&x_{l3} | x_{c}&!x_{l1}&x_{l2}&x_{l3} | x_{r2}&x_{l2}&x_{l3}\",\n",
+    "    \"COE_1_BIN\": 0b00000001_00010100_00110000_11010111_00010001_00001111_00111001_01010111_00000101_10110100_11111111_00010111_11110001_01111101_11111001_01010111,\n",
+    "    \"COE_1_STR\": \"!x_{r3}&!x_{r2}&x_{r1}&!x_{c}&x_{l1}&x_{l2} | !x_{r2}&!x_{r1}&x_{c}&x_{l1}&!x_{l2}&!x_{l3} | !x_{r3}&!x_{r1}&x_{c}&!x_{l1}&!x_{l2}&x_{l3} | x_{r3}&x_{r2}&x_{r1}&!x_{c}&!x_{l1} | x_{r3}&x_{r2}&!x_{r1}&x_{c}&!x_{l2} | !x_{r2}&x_{r1}&x_{c}&!x_{l1}&x_{l2} | x_{r2}&x_{r1}&x_{c}&x_{l2}&!x_{l3} | x_{r2}&!x_{r1}&x_{c}&!x_{l1}&x_{l3} | x_{r3}&!x_{r2}&x_{r1}&!x_{l2}&x_{l3} | x_{r3}&!x_{r2}&x_{r1}&x_{c} | x_{r2}&!x_{r1}&!x_{c}&x_{l1} | x_{r2}&x_{r1}&x_{c}&x_{l1} | x_{r3}&x_{r2}&!x_{c}&x_{l2} | x_{r3}&x_{c}&x_{l1}&x_{l2} | !x_{c}&x_{l1}&!x_{l2}&x_{l3} | !x_{r1}&!x_{c}&x_{l2}&x_{l3} | x_{r3}&x_{c}&x_{l2}&x_{l3}\",\n",
+    "    \"COE_2_BIN\": 0b00010100_01010001_00110000_01011100_00000000_01010000_11001110_01011111_00010111_00010001_11111111_01011111_00001111_01010011_11001111_01011111,\n",
+    "    \"COE_2_STR\": \"x_{r3}&!x_{r2}&x_{r1}&!x_{c}&!x_{l1}&!x_{l2} | x_{r3}&x_{r2}&x_{c}&!x_{l1}&!x_{l2} | x_{r2}&!x_{r1}&!x_{c}&x_{l1}&!x_{l2} | !x_{r2}&x_{r1}&x_{c}&x_{l1} | x_{r3}&x_{r2}&!x_{r1}&!x_{l2} | x_{r3}&!x_{r1}&x_{c}&x_{l2} | !x_{r3}&x_{r1}&x_{l1}&x_{l2} | !x_{r2}&!x_{c}&x_{l1}&x_{l2} | x_{r3}&x_{c}&x_{l1}&x_{l2} | x_{r3}&!x_{r1}&x_{c}&!x_{l3} | x_{r2}&x_{r1}&!x_{c}&x_{l3} | !x_{r2}&!x_{c}&x_{l1}&x_{l3} | x_{r3}&x_{c}&x_{l1}&x_{l3} | x_{r2}&x_{r1}&x_{l2}&x_{l3} | x_{r1}&!x_{c}&x_{l2}&x_{l3} | x_{r1}&x_{l1}&x_{l3}\",\n",
+    "    \"MM401_BIN\": 0b11111111_10101010_11111111_10101000_11111111_10101010_11111111_10101000_11110000_10101010_00000000_10101000_00000000_10101010_00000000_10101000,\n",
+    "    \"MM401_STR\": \"!x_{r1}&!x_{c}&!x_{l1}&!x_{l2} | !x_{r3}&!x_{r2}&x_{c} | !x_{r3}&!x_{r1}&x_{c} | !x_{r3}&x_{c}&!x_{l1} | !x_{c}&!x_{l3}\",\n",
+    "}\n",
+    "\n",
+    "# output_dict = {}\n",
+    "# # convert this into a list of outputs\n",
+    "# for item in automata:\n",
+    "#     if item[-3:] == 'BIN':\n",
+    "#         outputlist = [str(x) for x in bin(automata[item])[2:].zfill(128)]\n",
+    "#         output_dict[item] = outputlist\n",
+    "# print(output_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## automata schemata"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node = BooleanNode.from_output_list(automata_output_list[\"GEP_1\"])\n",
+    "# plot_schemata(node)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## finding the annihilation and generation rules of a lookup table"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This function detects all the annihilation rules (where the state of the automata changes from 1 to 0),\n",
+    "and all the generation rules (0 to 1) of a given wildcard ('#') schemata.  \n",
+    "\n",
+    "Filtering these rules directly from wildcard schemata isn't a straightforward process. This function detects it from the output list. It involves removal of annihilation/generation redundancies hidden in the schemata. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "GKL: [['###10#0', 0], ['1#10###', 1]]\n",
+      "\n",
+      "GP: [['0#01###', 0], ['0##1##0', 0], ['0##10##', 0], ['##10##1', 1], ['###01#1', 1], ['1##0##1', 1]]\n",
+      "\n",
+      "GEP_1: [['0##10##', 0], ['00#1###', 0], ['###0#11', 1], ['##10##1', 1]]\n",
+      "\n",
+      "GEP_2: [['##01##0', 0], ['###1#00', 0], ['11#0###', 1], ['1##01##', 1]]\n",
+      "\n",
+      "Das: [['#001###', 0], ['0#01###', 0], ['##01#0#', 0], ['##011#0', 0], ['1#001##', 1], ['###011#', 1], ['###01#1', 1], ['#1#01##', 1]]\n",
+      "\n",
+      "Davis: [['##110#0', 0], ['#1#100#', 0], ['#0010#1', 0], ['#1#10#0', 0], ['##0100#', 0], ['###1000', 0], ['1#100##', 1], ['#110#0#', 1], ['1110###', 1], ['0#1011#', 1], ['#1101##', 1], ['1#10#0#', 1]]\n",
+      "\n",
+      "ABK: [['0#01###', 0], ['0##1##0', 0], ['0##10##', 0], ['##10##1', 1], ['###01#1', 1], ['1##0##1', 1]]\n",
+      "\n",
+      "DMC: [['0##1100', 0], ['0#010##', 0], ['1011#01', 0], ['0#01#1#', 0], ['0#01##0', 0], ['#001#00', 0], ['00#101#', 0], ['0101###', 0], ['00#10#1', 0], ['#0#1100', 0], ['#111000', 0], ['01#1#00', 0], ['101110#', 0], ['#01101#', 0], ['#0110#1', 0], ['###0111', 1], ['11#0#1#', 1], ['11100#0', 1], ['11000#1', 1], ['1#0011#', 1], ['1#10#11', 1], ['0##01#1', 1], ['1010##1', 1], ['##101#1', 1], ['11001#0', 1], ['01101##', 1], ['#11011#', 1]]\n",
+      "\n",
+      "COE_1: [['##11010', 0], ['#111#00', 0], ['#0011#0', 0], ['101100#', 0], ['0#010#0', 0], ['01#10#0', 0], ['#1110#0', 0], ['#0#1100', 0], ['0##1010', 0], ['0001##0', 0], ['1#01110', 0], ['##11100', 0], ['0#0100#', 0], ['1#11#00', 0], ['1#110#0', 0], ['01010##', 0], ['#001001', 0], ['#00111#', 0], ['#1#1000', 0], ['10#1001', 0], ['11#00##', 1], ['1#10#11', 1], ['1#100##', 1], ['##00111', 1], ['#1#0#11', 1], ['#110100', 1], ['10#01#1', 1], ['1010###', 1], ['##1001#', 1], ['1##0111', 1], ['1#10#00', 1]]\n",
+      "\n",
+      "COE_2: [['##01#00', 0], ['0#01##0', 0], ['01011##', 0], ['#001##0', 0], ['001111#', 0], ['1001#0#', 0], ['00#1#10', 0], ['###10#0', 0], ['##0110#', 0], ['#110#0#', 1], ['#1101#0', 1], ['#000101', 1], ['1#101##', 1], ['#0#0011', 1], ['1##011#', 1], ['11#01##', 1], ['1010###', 1], ['1##01#1', 1], ['#01001#', 1], ['1#10#0#', 1], ['10#0#11', 1]]\n",
+      "\n",
+      "MM401: [['##1111#', 0], ['###1##1', 0], ['#0000##', 1], ['0##0###', 1]]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for item in automata_output_list:\n",
+    "    rules = annihilation_generation_rules(automata_output_list[item])\n",
+    "    print(f\"{item}: {rules}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Annihilation_generation_rules\n",
+    "\n",
+    "used jordan's algorithm and verified with the annihilation generation rules shown in [1].\n",
+    "\n",
+    "\n",
+    "[1] M. Marques, R. Manurung, and H. Pain, “Conceptual Representations: What do they have to say about the Density Classification Task by Cellular Automata?”.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annihilation_generation = {  # keeping annihilation and generation rules only\n",
+    "    \"GKL\": [[\"###10#0\", 0], [\"1#10###\", 1]],\n",
+    "    \"GP\": [\n",
+    "        [\"0##1##0\", 0],\n",
+    "        [\"0##10##\", 0],\n",
+    "        [\"0#01###\", 0],\n",
+    "        [\"##10##1\", 1],\n",
+    "        [\"1##0##1\", 1],\n",
+    "        [\"###01#1\", 1],\n",
+    "    ],\n",
+    "    \"GEP_1\": [[\"00#1###\", 0], [\"0##10##\", 0], [\"##10##1\", 1], [\"###0#11\", 1]],\n",
+    "    \"GEP_2\": [[\"###1#00\", 0], [\"##01##0\", 0], [\"1##01##\", 1], [\"11#0###\", 1]],\n",
+    "    \"Das\": [\n",
+    "        [\"##01#0#\", 0],\n",
+    "        [\"#001###\", 0],\n",
+    "        [\"##011#0\", 0],\n",
+    "        [\"0#01###\", 0],\n",
+    "        [\"###011#\", 1],\n",
+    "        [\"#1#01##\", 1],\n",
+    "        [\"1#001##\", 1],\n",
+    "        [\"###01#1\", 1],\n",
+    "    ],\n",
+    "    \"Davis\": [\n",
+    "        [\"##0100#\", 0],\n",
+    "        [\"#1#100#\", 0],\n",
+    "        [\"#1#10#0\", 0],\n",
+    "        [\"##110#0\", 0],\n",
+    "        [\"###1000\", 0],\n",
+    "        [\"#0010#1\", 0],\n",
+    "        [\"#110#0#\", 1],\n",
+    "        [\"1110###\", 1],\n",
+    "        [\"0#1011#\", 1],\n",
+    "        [\"1#100##\", 1],\n",
+    "        [\"1#10#0#\", 1],\n",
+    "        [\"#1101##\", 1],\n",
+    "    ],\n",
+    "    \"ABK\": [\n",
+    "        [\"0##1##0\", 0],\n",
+    "        [\"0##10##\", 0],\n",
+    "        [\"0#01###\", 0],\n",
+    "        [\"##10##1\", 1],\n",
+    "        [\"1##0##1\", 1],\n",
+    "        [\"###01#1\", 1],\n",
+    "    ],\n",
+    "    \"DMC\": [\n",
+    "        [\"#111000\", 0],\n",
+    "        [\"#0#1100\", 0],\n",
+    "        [\"00#101#\", 0],\n",
+    "        [\"0101###\", 0],\n",
+    "        [\"00#10#1\", 0],\n",
+    "        [\"#0110#1\", 0],\n",
+    "        [\"#01101#\", 0],\n",
+    "        [\"01#1#00\", 0],\n",
+    "        [\"101110#\", 0],\n",
+    "        [\"0#010##\", 0],\n",
+    "        [\"0#01#1#\", 0],\n",
+    "        [\"1011#01\", 0],\n",
+    "        [\"0##1100\", 0],\n",
+    "        [\"0#01##0\", 0],\n",
+    "        [\"#001#00\", 0],\n",
+    "        [\"##101#1\", 1],\n",
+    "        [\"1#10#11\", 1],\n",
+    "        [\"0##01#1\", 1],\n",
+    "        [\"11100#0\", 1],\n",
+    "        [\"01101##\", 1],\n",
+    "        [\"1#0011#\", 1],\n",
+    "        [\"###0111\", 1],\n",
+    "        [\"11#0#1#\", 1],\n",
+    "        [\"11000#1\", 1],\n",
+    "        [\"#11011#\", 1],\n",
+    "        [\"11001#0\", 1],\n",
+    "        [\"1010##1\", 1],\n",
+    "    ],\n",
+    "    \"COE_1\": [\n",
+    "        [\"#00111#\", 0],\n",
+    "        [\"##11010\", 0],\n",
+    "        [\"01010##\", 0],\n",
+    "        [\"#001001\", 0],\n",
+    "        [\"1#110#0\", 0],\n",
+    "        [\"#1#1000\", 0],\n",
+    "        [\"101100#\", 0],\n",
+    "        [\"#0011#0\", 0],\n",
+    "        [\"1#11#00\", 0],\n",
+    "        [\"##11100\", 0],\n",
+    "        [\"01#10#0\", 0],\n",
+    "        [\"#1110#0\", 0],\n",
+    "        [\"#0#1100\", 0],\n",
+    "        [\"0#010#0\", 0],\n",
+    "        [\"0##1010\", 0],\n",
+    "        [\"0001##0\", 0],\n",
+    "        [\"10#1001\", 0],\n",
+    "        [\"#111#00\", 0],\n",
+    "        [\"0#0100#\", 0],\n",
+    "        [\"1#01110\", 0],\n",
+    "        [\"1#10#11\", 1],\n",
+    "        [\"1##0111\", 1],\n",
+    "        [\"1010###\", 1],\n",
+    "        [\"##00111\", 1],\n",
+    "        [\"#110100\", 1],\n",
+    "        [\"1#100##\", 1],\n",
+    "        [\"11#00##\", 1],\n",
+    "        [\"#1#0#11\", 1],\n",
+    "        [\"10#01#1\", 1],\n",
+    "        [\"1#10#00\", 1],\n",
+    "        [\"##1001#\", 1],\n",
+    "    ],\n",
+    "    \"COE_2\": [\n",
+    "        [\"00#1#10\", 0],\n",
+    "        [\"01011##\", 0],\n",
+    "        [\"###10#0\", 0],\n",
+    "        [\"##01#00\", 0],\n",
+    "        [\"##0110#\", 0],\n",
+    "        [\"001111#\", 0],\n",
+    "        [\"#001##0\", 0],\n",
+    "        [\"1001#0#\", 0],\n",
+    "        [\"0#01##0\", 0],\n",
+    "        [\"#110#0#\", 1],\n",
+    "        [\"#01001#\", 1],\n",
+    "        [\"#0#0011\", 1],\n",
+    "        [\"1010###\", 1],\n",
+    "        [\"1#101##\", 1],\n",
+    "        [\"1##011#\", 1],\n",
+    "        [\"11#01##\", 1],\n",
+    "        [\"#000101\", 1],\n",
+    "        [\"1##01#1\", 1],\n",
+    "        [\"10#0#11\", 1],\n",
+    "        [\"1#10#0#\", 1],\n",
+    "        [\"#1101#0\", 1],\n",
+    "    ],\n",
+    "    \"MM401\": [[\"###1##1\", 0], [\"##1111#\", 0], [\"#0000##\", 1], [\"0##0###\", 1]],\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Maintenance rules\n",
+    "We have a function that detects annihilation and generation rules in a given schemata. Now we detect the remaining maintenance rules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "GKL : \n",
+      "[['0###0#0', 0], ['0##0###', 0], ['##0#0#0', 0], ['##00###', 0], ['1#1#1##', 1], ['1#1###1', 1], ['###11##', 1], ['###1##1', 1]]\n",
+      "\n",
+      "GP : \n",
+      "[['###0##0', 0], ['0#0#0##', 0], ['1##1###', 1], ['##1#1#1', 1], ['0##0##0', 0], ['1##1##1', 1]]\n",
+      "\n",
+      "GEP_1 : \n",
+      "[['##00#0#', 0], ['0###0#0', 0], ['###0##0', 0], ['00####0', 0], ['000##0#', 0], ['0#0#00#', 0], ['1##1###', 1], ['#11#1#1', 1], ['1####11', 1], ['#1#11##', 1], ['#1##111', 1], ['1#1###1', 1]]\n",
+      "\n",
+      "GEP_2 : \n",
+      "[['#0##000', 0], ['#0#00##', 0], ['0####00', 0], ['#00#0#0', 0], ['0#0###0', 0], ['0##0###', 0], ['1#1#11#', 1], ['###1##1', 1], ['111##1#', 1], ['##11#1#', 1], ['1###1#1', 1], ['11####1', 1]]\n",
+      "\n",
+      "Das : \n",
+      "[['###00##', 0], ['#010#00', 0], ['000##00', 0], ['#00#0##', 0], ['0#0#0##', 0], ['00#0#00', 0], ['##0#00#', 0], ['11#101#', 1], ['##1#11#', 1], ['11##111', 1], ['11#1#11', 1], ['##1#1#1', 1], ['##11###', 1], ['#11#1##', 1]]\n",
+      "\n",
+      "Davis : \n",
+      "[['001#0#0', 0], ['0#1#010', 0], ['0##001#', 0], ['00##000', 0], ['10#011#', 0], ['00#00##', 0], ['01##010', 0], ['##00###', 0], ['#10#0#0', 0], ['00#0#0#', 0], ['101##01', 1], ['##11#11', 1], ['#001#10', 1], ['#1#1#11', 1], ['1#1#10#', 1], ['#011##1', 1], ['1#1#011', 1], ['101#0#1', 1], ['###11##', 1], ['111##11', 1], ['#0000#1', 0], ['##0000#', 0], ['0#1111#', 1], ['#1111##', 1]]\n",
+      "\n",
+      "ABK : \n",
+      "[['###0##0', 0], ['0#0#0##', 0], ['1##1###', 1], ['##1#1#1', 1], ['0##0##0', 0], ['1##1##1', 1]]\n",
+      "\n",
+      "DMC : \n",
+      "[['#110001', 0], ['0##00##', 0], ['01##000', 0], ['#0#00#0', 0], ['#010##0', 0], ['#0#0#00', 0], ['00#0##0', 0], ['1#10100', 0], ['#01#010', 0], ['##00000', 0], ['1000#0#', 0], ['1#00101', 0], ['#0000##', 0], ['1101###', 1], ['1###111', 1], ['11#11##', 1], ['#11#1#1', 1], ['1#01#1#', 1], ['1##111#', 1], ['1#01##1', 1], ['#111#1#', 1], ['#001101', 1], ['11#1##1', 1], ['##1111#', 1], ['#011000', 1], ['0#1#1#1', 1], ['#111##1', 1], ['##1#111', 1], ['00##101', 1], ['0#000##', 0], ['0#00##0', 0], ['#000#00', 0], ['00#001#', 0], ['00#00#1', 0], ['#0#0100', 0], ['11#1#1#', 1], ['11010#1', 1], ['1#0111#', 1], ['11011#0', 1], ['#11111#', 1]]\n",
+      "\n",
+      "COE_1 : \n",
+      "[['0##0110', 0], ['##001#0', 0], ['0#00##0', 0], ['00#01#0', 0], ['#0000##', 0], ['0#00#0#', 0], ['00#0#0#', 0], ['00##100', 0], ['01##000', 0], ['#10010#', 0], ['#1#0101', 0], ['00101##', 0], ['#1#0110', 0], ['0##000#', 0], ['0##0#01', 0], ['#000##0', 0], ['110#01#', 1], ['##11#11', 1], ['0#11##1', 1], ['10010#0', 1], ['101#1#1', 1], ['#1#11#1', 1], ['10##101', 1], ['##111#1', 1], ['##1#011', 1], ['11#1##1', 1], ['##1111#', 1], ['#1##111', 1], ['#111##1', 1], ['1##1011', 1], ['###1101', 1], ['#0#1011', 1], ['01011##', 1], ['11##0#1', 1], ['101#11#', 1], ['1#0101#', 1], ['01#111#', 1], ['001100#', 1], ['11###11', 1], ['#10110#', 1], ['#11##11', 1], ['#0001#0', 0], ['0#000#0', 0], ['0000##0', 0], ['1#00110', 0], ['0#0000#', 0], ['#000001', 0], ['1#11#11', 1]]\n",
+      "\n",
+      "COE_2 : \n",
+      "[['0##0111', 0], ['#1000##', 0], ['01#0#11', 0], ['0100###', 0], ['00##110', 0], ['00#0#00', 0], ['0#0011#', 0], ['00#000#', 0], ['##0#0#0', 0], ['00#01#0', 0], ['100#00#', 0], ['#1#001#', 0], ['#00##00', 0], ['00101##', 0], ['00#011#', 0], ['0010#0#', 0], ['00##000', 0], ['#1##010', 0], ['##0000#', 0], ['#11#10#', 1], ['##1110#', 1], ['1#1##01', 1], ['1###111', 1], ['11##11#', 1], ['#11##01', 1], ['0##10#1', 1], ['#1#10#1', 1], ['###1011', 1], ['1##1#11', 1], ['#001#11', 1], ['##11#01', 1], ['101###1', 1], ['#1111##', 1], ['1#11##1', 1], ['#111##1', 1], ['##110#1', 1], ['0#00##0', 0], ['01001##', 0], ['001011#', 0], ['#1111#0', 1], ['1#111##', 1], ['#0#1011', 1], ['10#1#11', 1]]\n",
+      "\n",
+      "MM401 : \n",
+      "[['1#1#11#', 0], ['11#0###', 0], ['1#10###', 0], ['1#1###1', 0], ['1##01##', 0], ['1###1#1', 0], ['11####1', 0], ['0###0#0', 1], ['0####00', 1], ['###1#00', 1], ['##01##0', 1], ['#00#0#0', 1], ['0#0###0', 1], ['###10#0', 1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "anni_gen = {}\n",
+    "maintenance = {}\n",
+    "for item in automata_output_list:\n",
+    "    anni_gen[item] = annihilation_generation_rules(automata_output_list[item])\n",
+    "    maintenance[item] = maintenance_rules(automata_output_list[item])\n",
+    "\n",
+    "    # let's verify that the annihilation and generation rules combined with maintenance rules return the original rule\n",
+    "    combo = []\n",
+    "    combo = anni_gen[item] + maintenance[item]\n",
+    "    combo_node = BooleanNode.from_partial_lut(combo)\n",
+    "    parent_node = BooleanNode.from_output_list(automata_output_list[item])\n",
+    "\n",
+    "    assert (\n",
+    "        combo_node.outputs == parent_node.outputs\n",
+    "    ), \"Maintenance rules combined with annihilation and generation rules do not return the original rule. \"\n",
+    "\n",
+    "    print(f\"\\n{item} : \\n{maintenance[item]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## generating LUTs from annihilation generation rules from given criteria"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "????????0?0?????????????0?0?????????????0?0?????????????0?0?????????????0?0?????111111110?0?????????????0?0?????111111110?0?????\n",
+      "6.44e+27 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
+      "No. of '?' in output = 96.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.375.\n"
+     ]
+    }
+   ],
+   "source": [
+    "node = BooleanNode.from_partial_lut(annihilation_generation[\"GKL\"])\n",
+    "print(\"\".join(node.outputs))\n",
+    "\n",
+    "\n",
+    "# from a given bias criterion\n",
+    "nodes_from_bias = node.generate_with_required_bias(bias=0.5, verbose=True)\n",
+    "\n",
+    "# from a given effective connectivity criterion\n",
+    "nodes_from_ec = node.generate_with_required_effective_connectivity(\n",
+    "    effective_connectivity=0.375, shuffle=True, verbose=True\n",
+    ")\n",
+    "\n",
+    "nodes_randomly = node.fill_missing_output_randomly()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# plotting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def plot_hist(\n",
+    "    generated_node_values,\n",
+    "    value_type=None,\n",
+    "    no_of_columns=4,\n",
+    "    title=None,\n",
+    "    save=False,\n",
+    "    filename=None,\n",
+    "    include_parent=False,\n",
+    ") -> None:\n",
+    "    \"\"\"\n",
+    "    Plot histogram of generated node values.\n",
+    "\n",
+    "    Args:\n",
+    "    generated_node_values (dict): Dictionary of generated node values.\n",
+    "    value_type (str): Type of value to plot. Must be 'ke' or 'bias'.\n",
+    "    no_of_columns (int): Number of columns in the plot.\n",
+    "\n",
+    "    Returns:\n",
+    "    None\n",
+    "\n",
+    "    Example:\n",
+    "    generated_node_values = {\n",
+    "        \"Rule 1\": [0.1, 0.2, 0.3, 0.4, 0.5],\n",
+    "        \"Rule 2\": [0.2, 0.3, 0.4, 0.5, 0.6],\n",
+    "    }\n",
+    "    plot_hist(generated_node_values, value_type='ke')\n",
+    "    \"\"\"\n",
+    "\n",
+    "    if value_type == \"ke\":\n",
+    "        parent_rule_label = \"Parent Rule $K_e$\"\n",
+    "        xlabel = \"Effective Connectivity\"\n",
+    "        ylabel = \"Count\"\n",
+    "    elif value_type == \"bias\":\n",
+    "        parent_rule_label = \"Parent Rule Bias\"\n",
+    "        xlabel = \"Bias\"\n",
+    "        ylabel = \"Count\"\n",
+    "    elif type(value_type) is not str and value_type not in [\"ke\", \"bias\"]:\n",
+    "        xlabel = value_type\n",
+    "        ylabel = \"Count\"\n",
+    "    else:\n",
+    "        raise ValueError(\"Invalid value_type. Must be 'ke' or 'bias'.\")\n",
+    "    if title is None:\n",
+    "        title = f\"Distribution of Generated {value_type.capitalize()} Values\"\n",
+    "\n",
+    "    total_plots = len(generated_node_values)\n",
+    "    no_of_rows = int((total_plots / no_of_columns) + 1)\n",
+    "    # plot hist ke in subplots\n",
+    "    fig, axs = plt.subplots(no_of_rows, no_of_columns, figsize=(25, 15))\n",
+    "    fig.suptitle(\n",
+    "        title,\n",
+    "        fontsize=25,\n",
+    "    )\n",
+    "    min_max, parent_rule_values = min_max_and_parent_rule_values(\n",
+    "        automata_output_list,\n",
+    "        generated_node_values,\n",
+    "        value_type=value_type,\n",
+    "        include_parent=include_parent,\n",
+    "    )\n",
+    "    for i, rule in enumerate(generated_node_values):\n",
+    "        ax = axs.flatten()[i]\n",
+    "        # make each subplot axes equal in value range\n",
+    "        ax.set_xlim(min_max)\n",
+    "        # ax.set_ylim(0, max_count)\n",
+    "\n",
+    "        ax.hist(generated_node_values[rule], bins=100, color=\"blue\", alpha=0.7)\n",
+    "        ax.set_title(rule, fontsize=20)\n",
+    "        ax.set_xlabel(xlabel)\n",
+    "        ax.set_ylabel(ylabel)\n",
+    "        ax.text(\n",
+    "            0.2,\n",
+    "            0.9,\n",
+    "            f\"Total Count: {len(generated_node_values[rule])}\",\n",
+    "            horizontalalignment=\"center\",\n",
+    "            verticalalignment=\"center\",\n",
+    "            transform=ax.transAxes,\n",
+    "            fontsize=10,\n",
+    "        )\n",
+    "\n",
+    "        if parent_rule_values and parent_rule_label:\n",
+    "            # plot parent rule value as a line\n",
+    "            ax.axvline(\n",
+    "                parent_rule_values[rule],\n",
+    "                color=\"red\",\n",
+    "                linestyle=\"--\",\n",
+    "                label=f\"{parent_rule_label}: {parent_rule_values[rule]:.2f}\",\n",
+    "            )\n",
+    "            # ax.text(\n",
+    "            #     parent_rule_values[rule],\n",
+    "            #     .5,\n",
+    "            #     f\"{parent_rule_values[rule]:.2f}\",\n",
+    "            #     rotation=90,\n",
+    "            #     fontsize=10,\n",
+    "            # )\n",
+    "\n",
+    "            ax.legend(fontsize=\"large\", loc=\"upper right\")\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.subplots_adjust(top=0.92)\n",
+    "    if save:\n",
+    "        plt.savefig(filename)\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "def plot_scatter(\n",
+    "    first_values,\n",
+    "    second_values,\n",
+    "    label: list[str, str] = [\"ke\", \"bias\"],\n",
+    "    no_of_columns=4,\n",
+    "    title=None,\n",
+    "    save=False,\n",
+    "    filename=None,\n",
+    "    include_parent=False,\n",
+    ") -> None:\n",
+    "    \"\"\"\n",
+    "    Plot scatter plot of generated rules.\n",
+    "\n",
+    "    Args:\n",
+    "    first_values (dict): Dictionary of first values.\n",
+    "    second_values (dict): Dictionary of second values.\n",
+    "    label (list): List of labels. Must be 'ke' or 'bias'.\n",
+    "    no_of_columns (int): Number of columns in the plot.\n",
+    "\n",
+    "    Returns:\n",
+    "    None\n",
+    "\n",
+    "    Example:\n",
+    "    first_values = {\n",
+    "        \"Rule 1\": [0.1, 0.2, 0.3, 0.4, 0.5],\n",
+    "        \"Rule 2\": [0.2, 0.3, 0.4, 0.5, 0.6],\n",
+    "    }\n",
+    "    second_values = {\n",
+    "        \"Rule 1\": [0.2, 0.3, 0.4, 0.5, 0.6],\n",
+    "        \"Rule 2\": [0.3, 0.4, 0.5, 0.6, 0.7],\n",
+    "    }\n",
+    "    plot_scatter(first_values, second_values, label=['ke', 'bias'])\n",
+    "    \"\"\"\n",
+    "    if label[0] == label[1]:\n",
+    "        raise ValueError(\"Invalid labels. Must be different.\")\n",
+    "    if label[0] == \"ke\":\n",
+    "        xlabel = \"$K_e$\"\n",
+    "        if label[1] == \"bias\":\n",
+    "            ylabel = \"Bias\"\n",
+    "\n",
+    "    elif label[0] == \"bias\":\n",
+    "        xlabel = \"Bias\"\n",
+    "        if label[1] == \"ke\":\n",
+    "            ylabel = \"$K_e$\"\n",
+    "    else:\n",
+    "        raise ValueError(\"Invalid labels. Must be 'ke' or 'bias'.\")\n",
+    "\n",
+    "    if title is None:\n",
+    "        title = f\"Scatter plot of {xlabel} and {ylabel} of generated rules.\"\n",
+    "\n",
+    "    total_plots = len(first_values)\n",
+    "    no_of_rows = (\n",
+    "        int((total_plots / no_of_columns) + 1) if total_plots > no_of_columns else 1\n",
+    "    )\n",
+    "\n",
+    "    fig, axs = plt.subplots(no_of_rows, no_of_columns, figsize=(25, 15))\n",
+    "    fig.suptitle(\n",
+    "        title,\n",
+    "        fontsize=25,\n",
+    "    )\n",
+    "    min_max_x, parent_rule_values_x = min_max_and_parent_rule_values(\n",
+    "        automata_output_list,\n",
+    "        first_values,\n",
+    "        value_type=label[0],\n",
+    "        include_parent=include_parent,\n",
+    "    )\n",
+    "    min_max_y, parent_rule_values_y = min_max_and_parent_rule_values(\n",
+    "        automata_output_list,\n",
+    "        second_values,\n",
+    "        value_type=label[1],\n",
+    "        include_parent=include_parent,\n",
+    "    )\n",
+    "    # plot scatter if first value and second value for\n",
+    "    rules = list(first_values.keys())\n",
+    "    for i, rule in enumerate(rules):\n",
+    "        ax = axs[int(i / no_of_columns), i % no_of_columns]  # TODO: [SRI] Fix the indexing\n",
+    "\n",
+    "        ax.scatter(\n",
+    "            first_values[rule],\n",
+    "            second_values[rule],\n",
+    "            label=f\"Rule {rule}\",\n",
+    "            alpha=0.5,\n",
+    "        )\n",
+    "\n",
+    "        ax.set_title(f\"Rule {rule}\")\n",
+    "        ax.set_xlabel(xlabel)\n",
+    "        ax.set_ylabel(ylabel)\n",
+    "        ax.grid()\n",
+    "        ax.set_xlim(min_max_x)\n",
+    "        ax.set_ylim(min_max_y)\n",
+    "\n",
+    "        # plot parent rule values\n",
+    "        ax.scatter(parent_rule_values_x[rule], parent_rule_values_y[rule], c=\"red\")\n",
+    "        ax.legend()\n",
+    "\n",
+    "    for i in range(total_plots, no_of_columns * no_of_rows):\n",
+    "        fig.delaxes(axs[int(i / no_of_columns), i % no_of_columns])\n",
+    "    plt.tight_layout()\n",
+    "    if save:\n",
+    "        plt.savefig(filename)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### $K_e$ and Bias in generated rules"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plotting $K_e$ and Bias in generated rules from anni_gen rules with missing outputs filled randomly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2500x1500 with 11 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rules = (\n",
+    "    \"GKL\",\n",
+    "    \"GP\",\n",
+    "    \"GEP_1\",\n",
+    "    \"GEP_2\",\n",
+    "    \"Das\",\n",
+    "    \"Davis\",\n",
+    "    \"ABK\",\n",
+    "    \"DMC\",\n",
+    "    \"COE_1\",\n",
+    "    \"COE_2\",\n",
+    "    \"MM401\",\n",
+    ")\n",
+    "\n",
+    "\n",
+    "generated_nodes = {}\n",
+    "limit = 10000\n",
+    "shuffle = \"maintenance\"\n",
+    "save = False\n",
+    "\n",
+    "\n",
+    "# parallelize the loop\n",
+    "def worker(item):\n",
+    "    \"\"\"\n",
+    "    Worker function to be executed by each process.\n",
+    "    \"\"\"\n",
+    "    node = BooleanNode.from_partial_lut(annihilation_generation[item])\n",
+    "    generator = node.fill_missing_output_randomly()\n",
+    "\n",
+    "    return item, collect_data_from_generator(generator, limit=limit)\n",
+    "\n",
+    "\n",
+    "# Use ProcessPoolExecutor to parallelize the loop\n",
+    "with ProcessPoolExecutor() as executor:\n",
+    "    results = executor.map(worker, rules)\n",
+    "\n",
+    "# Process results\n",
+    "for item, (nodes, bias, ke, count) in results:\n",
+    "    generated_nodes[item] = {\"nodes\": nodes, \"bias\": bias, \"ke\": ke, \"count\": count}\n",
+    "\n",
+    "\n",
+    "title = \"Scatter plot of $K_e$ and Bias of rules generated from anni_gen with missing outputs filled randomly.\"\n",
+    "filename = \"Scatter plot of $K_e$ and Bias of rules generated from anni_gen with missing outputs filled randomly.png\"\n",
+    "plot_scatter(\n",
+    "    first_values={k: v[\"bias\"] for k, v in generated_nodes.items()},\n",
+    "    second_values={k: v[\"ke\"] for k, v in generated_nodes.items()},\n",
+    "    label=[\"bias\", \"ke\"],\n",
+    "    no_of_columns=4,\n",
+    "    title=title,\n",
+    "    save=save,\n",
+    "    filename=filename,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plotting $K_e$ in generated rules from anni_gen rules with with parent rule bias "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAACbkAAAXDCAYAAAD3YaHZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU1eL/8c8mpIeEmoQSAkozVEWESEcEERARKyrBnw0uYuHq5YsXlSKicPWCV0SxABbsoIgUASkiHQxVEJF2gRAQk0BCQsr8/sjNmCVtk2yZJO/X8+yTnZ2zM2dmd04+O3v2jM0wDEMAAAAAAAAAAAAAAAAAAFiQl6crAAAAAAAAAAAAAAAAAABAYejkBgAAAAAAAAAAAAAAAACwLDq5AQAAAAAAAAAAAAAAAAAsi05uAAAAAAAAAAAAAAAAAADLopMbAAAAAAAAAAAAAAAAAMCy6OQGAAAAAAAAAAAAAAAAALAsOrkBAAAAAAAAAAAAAAAAACyLTm4AAAAAAAAAAAAAAAAAAMuikxsAAAAAAAAAAAAAAAAAwLLo5AYAAAAAAAAAAAAAAAAAsCw6uQEAAAAAAAAAAAAAAAAALItObgAAAJVM9+7dZbPZZLPZNHfuXE9Xx+kc3b6GDRua5dasWeO2+rlTRX+tPS0jI0PvvPOO+vTpozp16sjPz8/c3w0bNvR09SqsyrDfOXYB61mzZo3L2prK0K7BOvgfg7xc+X6oDJ+3AEeVl7bXVcdtedl+AAAAWF8VT1cAAAAAOYYNG6Z58+YVOM/Ly0shISEKDQ1VaGiomjVrpnbt2ql9+/bq2rWrqlQh1gHudP78ed1www3aunWrS5a/adMmxcTE2E136NCh2Of9/PPPGjhwoI4fPy5JstlsmjBhgp577jmX1NPdXL3fAcDdaNcAAAAAAAAAx/BtKAAAQDmQnZ2txMREJSYmSpJ27dqlL774QpJUp04dPfjggxo5cqQiIiI8WMuCNWzYUEePHpUkrV69Wt27d/dshcop9qO1PPvss3YdEho0aKDGjRvLx8dHkhQeHl6m5f/888/mfW9vb7Vu3brY53z55ZeKjY1VamqqJCkoKEgffvihBg0aVKa6WImr9zsA1+J/WX60awDKA9pvOBPvJwAAAAClRSc3AAAAC6pevbquu+46u8dSU1P1559/Kj4+XmfPnjUfP3XqlF588UXNmjVLb7/9tgYPHuzu6gKVSlZWlt2oi5MnT9azzz7r1HXk7eTWtGlTBQQEFFrWMAxNmDBBEydOlGEYknI6SSxatEht2rRxar08yR37HQDciXYNAAAAAAAAcByd3AAAACyodevWWrZsWaHzf//9d/3www964403tHPnTknSH3/8odtvv10vv/yyxowZU+hz16xZ4+zqWkpF376SYF+4xq+//qrz589LkqpUqaJnnnnG6euIi4sz71999dWFlktJSdHQoUO1YMEC87FOnTppwYIFCgsLc3q9PMkd+x0A3Il2DZ5APkRevB8AuANtDQAAAJzFy9MVAAAAQMldccUVeuihhxQXF6e5c+fajfI0duxYLVy40IO1Ayq2c+fOmfcjIiLMS8o5S2Zmpnbv3m1Ot23btsByx44dU+fOne06uD3wwAP64YcfKlwHN8n1+x0A3I12DQAAAAAAAHAcndwAAADKudjYWK1YsUJVquQM0msYhh599FGlpqZ6uGZAxZSRkWHe9/b2dvry9+/fr7S0NHO6oJHcfvrpJ7Vv394c8c3b21uvvfaa3n//ffn6+jq9Tlbg6v0OAO5GuwYAAAAAAAA4jk5uAAAAFUCnTp00ceJEc/rMmTN65513CizbvXt32Ww22Ww2zZ07t8jlpqen68MPP9Rtt92mK664QsHBwapSpYpCQkLUpEkT3XzzzRo/frw2bdokwzDM5x05csRcx9GjR83He/ToYT6e99a9e/d8627YsKE5P/fSFufPn9fbb7+tXr16KSoqSn5+fnbzS7p9l0tMTNSMGTN0/fXXKyIiQv7+/mrUqJHuvfderV692qFl5N2uI0eOFFt+zZo1ZvmGDRvazSvrfizNvjhx4oQmT56sTp06qU6dOvLz81NYWJjatWunsWPH6pdffnFoOQW9funp6ZozZ4569uypevXqyc/PT3Xr1tXAgQPtRiNzhbJuV97XqUePHubjR48eLfC1KIu8lyqV8o/k9v7776tnz55KSEiQJIWGhmrx4sV66qmnyrReVynLvnfXfi9te+PM472sDMPQ119/rQceeEDNmzdX9erVFRAQoAYNGuiWW27R+++/b9ehpjilbf+d4fvvv9fdd9+tqKgo+fv7q06dOurUqZP+85//KDk5WVLp9qWz9pE72jdX1tWR93auixcvatGiRXriiSfUpUsXRUREyM/PT0FBQWrQoIH69++v119/XRcuXCi0Ds7IBK7YN3mtW7dO999/vxo1aiR/f39FRETo+uuv1/Tp05WYmFiiZRWnLO1aWV/PXK78X5+cnKz//Oc/6tSpk/l+iYqK0kMPPaTffvst3zKys7P12Wef6eabb1Z4eLh8fX0VERGhgQMHasWKFQ7Vo6Sc8b7Oy1VtgquWW5asXBZWb9slz+bXN954w1x3//79iyyb9zW02Wzas2dPoWWXLVtmlmvevHmRy7r8/eDs9lvyzOeBgl5XZ3zuk9zTnpS0nbfqMeGK91NJ6u3ofrRKvndF3iktZxwvjv7vcfYxlcuTn20AAADgZAYAAAAsITY21pBkSDK6detW4udfuHDBCA0NNZdx1VVXFViuW7duZpk5c+YUury4uDijadOmZtnibp999pn53MOHDzv8vMK2Nyoqypy/evVqY8uWLUajRo0KfP7q1atLvH2XL3/79u12jxV0e+CBB4z09PQiX4e85Q8fPlxkWcMwjNWrV5vlo6Ki7OaVdT86ui9yvfrqq0ZQUFCR66hSpYrx1FNPGRkZGUUu6/L9e/DgQaNt27ZFLnvQoEHF7t/ScMZ25X2dHLmVxejRo83l1K9f33w8MzPTePLJJ+3W06RJE2P//v1lWp8rlXXfu2u/l7a9cebxnldJj91t27YZV199dbH7p0mTJsa2bduKXV5Z2v+ySE1NNe68884i19WoUSNjx44dDu/LXM7cR65u31xZV0ff24ZhGPPnzzeqVq3q0HugRo0axqJFiwqsgzMygSv2jWEYRkZGhvHII48UuayoqChj+/btJX7PFaYs7VpZXs9crvxfHxcXZ1x55ZWFLjcgIMCuXmfOnDG6du1aZF2effbZUu/rgjjrfV3UfnBWm+Cq5Zb0f0xZlZe23TA8m1937dplLjM0NNTIzMwssNzFixcNPz8/uzr85z//KXS5Y8aMMcs9+uij+eYX9X4oa/ttlc8Drvrc5472pKTtvJWPCWfmAVfux7zzPJXvnf06loSrjhdHtt8Vx5RheO6zDQAAAFwj55pWAAAAKPeCgoJ099136+2335Yk/fLLLzpz5oxq165d4mWdOnVKN9xwg/744w/zsWrVqqlZs2aqWrWqUlNTderUKR05csT8lWt2drZZNiAgQH369JEkrV271rz0Yvv27VWjRo1862vdunWR9fntt9/097//3RzloXHjxqpfv74SExO1f//+Em/f5Y4fP64nn3xS586ds1v+mTNntG/fPnMb58yZo+TkZH3++efy8nL9oMjO3o9F+fvf/67XXnvN7rHc/XD27Fnt3btXhmEoMzNT//73v/X777/ryy+/NC+TW5T4+Hjdd999OnHihCSpadOmqlevnhITE7Vr1y5lZWVJkhYuXKjRo0frjTfeKPV2uGq7atSoYb4W586d09atWyVJ/v7+6tatm9PqK9mP5JZ7qdLExETddddd+v777815vXr10ueff67q1as7df3O4ox97879nsvV7Y2zLVu2TLfffrtSUlLMx2rVqqUmTZrIz89Phw8fNkfLOHjwoHr06KHly5crJiamwOWVtf0vrczMTA0aNEjLly83H7PZbGrRooVq166tU6dOaf/+/Tp8+LB69eqlGTNmOLxsZ++jvJzdvrmyriV9bx86dEjnz583p8PCwtSwYUNVrVpVFy9e1K+//qqzZ89Kyjk+b731Vn399dcaMGCA3XKc9b/M2fvGMAwNHTpUn3zyid3j0dHRCgsL04kTJ3Tw4EEdPXpUN954Y4nec0VxVrtWmrbKlf/rjx8/rjvuuENnz56Vl5eXWrZsqZo1a+rYsWM6dOiQpJzRWQYMGKCff/5ZdevW1Y033mj+z2vUqJGioqKUlJSknTt3mu3KSy+9pJYtW+qee+5xeN8UxVnv68K4KvN4MkuVRXlt2yX37/OWLVuqVq1aOnv2rJKSkvTzzz/r2muvzVdu06ZNSk9Pt3tszZo1euyxxwpc7uUjXpeEMz+LWOU97MzPfa5uT0razlv9mHDnZ9u8Knu2Lwt3nydxxTHlqc82AAAAcCEPda4DAADAZco6kpthGMa8efPsfoG6YMGCfGUc+QXtY489ZpapW7eusXjxYiMrKytfuT///NP45JNPjBtvvNH49NNPC1zW5b8EdlTe5+X+mvfGG280fvnlF7ty586dM86dO1ei7bt8+bVq1TIkGddcc42xY8cOu3KHDh0yevXqZbdfZ86cWehy85Zz5i+/S7MfHd0Xn3/+uV2927dvb8TFxdmVOXLkiNG/f3+7chMnTnSovjVr1jQkGbfccotx8OBBu3LHjx83evToYZb18vIyfv31V4e2rziu2C7DcPw1K60aNWqYy3/uueeM/fv35/vl+ahRowod4cMKXLHvXbnfS9veuOp4d/TYPXjwoBEcHGyWve6664w1a9YY2dnZduU2b95sNxpEVFSUkZiYWOAyndn+l8Qrr7xitz8HDBhgHDlyxK7M/v37je7du9u128XtS1fsI1e1b66ua0ne24ZhGC+++KLRqVMnY/bs2caJEycKXP6PP/5odOjQwe7/aXJycqHbWNpM4Ip98+6779q957p3757v9YmLizOuueaaEr3nSqKk7VpZXk9X/6/P/d917733GidPnrQrt3LlSrvRhocOHWqMHDnSkGRce+21+Uah+e2334xWrVqZ5SMjIwtsh0rD1e9rZ7YJrlquO0dyK09tu2F4Pr/edttt5jKnTZtWYJkXXnjBLBMQEGBIMmrXrp1v2w3DMM6fP29UqVLFLH/q1Kl8ZUo7CrYjPL0/C6qHMz/3ubo9KUk7X96OidLmAUeV5f9l3tff3fneVa9jSbjqeHFk+11xTHnqsw0AAABch05uAAAAFuGMTm67d++2O8lY0JcjjpxcvOKKK8wyK1eudGjdhXW4cUYnN0lG3759i71slmGU7osaSUaLFi2MpKSkAsteunTJ7qR9aGhooSdSXXVS3FWd3NLT042IiAiz3DXXXGNcuHChwLJZWVnGLbfcYpb18fExjh8/Xmx9JRlDhgwp8Ms3w8j5Aq5u3bpm2eeee86h7SuKq7bLMFzb2erIkSN2++3RRx81qlWrZle32bNnO3Wdzuaqfe+uTm4laW88+SWYYRh2l/kbMGCAcenSpULLXrhwwe7yUoV1XHFm+++oP//80wgMDLTblsI6tKSlpRmdO3e22/dF7UtX7CNXtW/uqKuj7+3cdTji4sWLRseOHc11vPHGG4WWLW0mcPa+uXjxol1nmk6dOhlpaWkFLi8pKcmIjo52+D1XEmXp5FaS19Nd/+sfeuihQuuQ94cY3t7ehpeXl9G2bVvj/PnzBZb/9ddf7Trn/PDDD8VupyNc/b52ZpvgquW6q5NbeWvbDcPz+fX11183l9evX78Cy+S+fgEBAcbw4cPN8rt3785XdunSpeb8Zs2aFbm84t4PZe3k5on9WVg9nPW5zx3tiaPtfHk7JtzZya2k+Sfv89yd7131OpaEq44XR7bfFceUJz7bAAAAwLVcf40lAAAAuE2tWrXspv/8889SLee///2veb9Tp04OPcfb27tU63KEr6+v3nnnHYcul1Vas2bNUkhISIHzfHx89M4778jHx0eSlJSUpE8//dRldXGnr776SvHx8ZJyLh/13nvvKSgoqMCyXl5emj17tqpWrSpJysjIMC+PW5Rq1app1qxZstlsBc4PDg7WQw89ZE7/9NNPJd2MfNyxXa6Q91KlkvT2228rMTFRUs7xvXLlSj388MPur1gJlNd9n8sd7Y0zbN68WevWrZMk1axZUx988IHZRhUkKChIb731ljn91ltvmZfkycsT7f/HH3+s1NRUSTmXbJw1a1ahlzry8/PT7NmzC21P8nLVPsrLWe2bO+pa0vd2Ycft5fz9/TV58mRz+ptvvnHoeY5yxb756quvzMtdeXt765133pGfn1+BywsJCdGsWbPKuhlOV5LX0x3tcs2aNTV9+vRC5999991mzsrKylJ2drbeeustBQcHF1i+SZMm6tmzpzntjGwguf597arM44ksVVbluW2XPLPP815OdP369eblH3Olp6dr8+bNkqSOHTual36U7C9Lmmvt2rXmfVdd5t1RVnoPO+tzn6vbE0fb+Yp8TDhDZc/2ZeXO8ySuOKasdm4LAAAAZUcnNwAAgAqkevXqdtPnzp0r1XL8/f3N+7t27SpTnZyhX79+qlevnsuW36ZNG3Xp0qXIMldeeaVuuukmc/rrr792WX3cKe92dOvWTW3bti2yfHh4uIYMGVLg8wuT94vtwnTu3Nm8v3///mKXWRx3bJcr/Pzzz4XOmzdvnrp27erG2pROed33uVzd3jjLhx9+aN6PjY1VtWrVin1Ohw4d1LhxY0nSyZMnCzzWPNH+L1myxLzfv3//Yvf/VVdd5dCx4Kp9lJez2jd31NWV7+0OHTqY97dt2+bUZbti3+RtZ3r06KGrrrqqyOV17dpVrVq1crzSblCS19Nd/+uL+nLa19dXbdq0MadbtGhh974pSN75v/zyS7F1cLbSvK9dlXk8kaXKqjy37ZJn9nnLli1Vs2ZNSTmdRS7PhZs2bVJaWpqknA5xXbt2NTscFdTJLe9jeTvQeYJV3sOe+txXmvbE0Xa+Ih8TzlDZs31ZWPk8iaPHlNXObQEAAKDs6OQGAABQgWRnZ9tNOzIaQkHatWtn3r/vvvs8/ivsvCfLXSHvSdmi9O3b17y/detWV1XHrXJHg5Dst68o/fv3N+/v27dP58+fL7J8TExMscvM+8VD7shlZeGO7XKFvCO5NW/e3BxJR5KefPJJp+wbVyuv+z6Xq9sbZ/nxxx/N+3lHOypOy5Ytzfs7duzIN98T7X/e9rRHjx4OPceRL+tdtY/yclb75o66luW9ffjwYb377rt6/PHHdc8996h///666aabzNvgwYPNsn/++ac5epMzuGLf5H3P5R0JqSiOtmfuUpLX0x3tcnEd1iQpIiLCvN+xY8cSlXfF/z9XvK9dlXk8kaXKqjy37ZJn9rnNZrPr6Hd5x7XLO63VqFFDrVu3liStW7fObhSnlJQUu44fnu7kZpX3sKs+97miPXG0na/Ix4QzVPZsXxaePE/irGPKaue2AAAAUHbWHqMZAAAAJZKUlGQ3XaNGjVIt54knntDq1aslSQcPHlTnzp3VpEkT3XTTTeratau6dOmi8PDwMtfXUVdeeaVLl5/3xHBRWrRoYd4/c+aMkpKSFBoa6qpquVxmZqaOHj1qTjs6Sk3ectnZ2Tp8+LD5BVtB8n5JXZjAwEDzflk7R7hru1wh74gd/fv31/XXX6/BgwfLMAwdPHhQd999t5YsWVLo5b48rTzv+1yubm+cwTAM7d2715x+6aWX9J///Meh5+7evdu8n3u5xrzc3f6npaXpzJkz5nTz5s0del5xI2+5ch/l5Yz2zV11Lc17e//+/XriiSe0YsWKEl0CKykpyW67S8sV+yYjI8OunSpNBrACR19Pd7XLjrQLed8TYWFhJSrvzI6TrnxfuyrzuDtLlVV5b9slz+3z7t27a+HChZJyOrU9/fTT5rzcTm4BAQFmx9Lu3btr586dOnPmjPbu3Wu2aevXr1dmZqYkqWnTpqpTp45T6ldaVnkPO/tznyvbE0fa+cpwTJRVZc/2ZeGJ8yTOPqasdm4LAAAAZUcnNwAAgAok75dJUuk7uQ0cOFAvvfSSxo0bZ44Od/DgQR08eNA82dqqVSvdcccdeuihh1z+pUne0axcIfeyQCUtl5iYWK47uV3+63pH90OtWrXspv/8888iy/v6+paoXmXlru1ytnPnzunYsWPmdNu2bTVo0CCNGzdOkyZNkiQtX75cY8aM0bRp09xaN0eV132fl6vbG2dISkpSVlaWOb1hw4ZSL+dy7m7/L3/POHJpJknFtr2u3Ed5OaN9c1ddS/reXrdunfr27VuqL6nT09NL/JyCuGLflLadcrScuzj6elr1f31Jy5fki+6iuPp97arM4+4sVVblvW2XPLfP8464tn79emVlZcnb21vp6enatGmTpJwRtfz8/MzyM2bMkJTTCS63U4qVLlUqWec97MzPfa5uTxxp5yvDMVFWlT3bl4W7z5O44piy2rktAAAAlJ01f/4PAACAUtm+fbvddFl+tTx27Fjt2LFD9913n4KDg/PN3717t55//nk1btxYr776aqnX4whXj1rl6An73C+TcjnrS3xPubz+ju6Hy8tZbT+U1+3Ke6lSKaeTmyRNmDBB/fr1Mx//17/+pfnz57uxZo4rr/s+L6uOkpdXSkqKU5Zz+SWuc1mp/S9Mca+Tq/eRM7mrriV5bycnJ+uOO+4wv2SsWrWqnnjiCX333Xc6ePCgzp8/r8zMTBmGYd5cwRX75tKlS3bzSpsBPM3R17MitMvOYpX3NQpXkdr20mrVqpXZYSQpKckc5Xfz5s1KS0uTZN9prWvXrrLZbJLsO7atXbvWvN+tWzcX17r8cNbnPne0J46085XhmCgrsn3pufM8iSuPqfLw2QYAAACOYyQ3AACACuSnn34y79tsNnXu3LlMy2vTpo0+/PBDZWRkaOvWrVqzZo3Wrl2rdevWmV+ypKam6umnn5aXl5eeeuqpMq3PU86fP1+qciEhIWVed95fbLvb5b+uLu1+cHR0Dncpr9uV91KlAQEB5qW9bDabPv74Y1133XX69ddfJUkPPfSQmjVrpnbt2rm1jsUpr/veXZx1vF++n7du3aprr73WKcvO5a72//JtcXQEiuJGlXLHPnIWK9b1/fffV0JCgiSpevXq2rx5s5o0aVJoeUeP9ZJyxb65/H93adup8oJ2+S9WeV9XBrTtpWez2dSlSxd9/fXXknI6rl177bWFjsxWo0YNtW7dWjt37tS6detkGIZSU1O1bdu2AstXds763GeV9qQyHBNW54x8b9XX0Z3nSVx9TFWWc1sAAACVgfV/xgIAAACHnD9/Xp999pk5HR0d7bRLa/n4+Oj666/Xs88+q+XLl+vs2bN6++237S5l9cILLzjtF8judvjw4RKXq1KlSoGXg/Xx8THvZ2RkFLvMyy/n5E7BwcEKCAgwpx3dD4cOHbKbrl27tlPrVVbldbvydnJr2bKlvL29zenQ0FB9/fXX5uV2Ll68qEGDBplfBJTEzp079eijj6pp06YKDAxUcHCwrrvuOr311ltl/vV/ed33peWp4z04OFiBgYHmdGneB45ydfsfEBBgt6z9+/c79LziyrlzH5WVFeu6YsUK8/4TTzxR5JeMknTixAmX1MMV+6Zq1ap27dSRI0ccep6j7ZnVVLZ2uShWeV9XBrTtZZO3U1pu57bcvwEBAerQoUOB5c+cOaO9e/fqp59+MnNJkyZNVLduXVdXudxw1uc+q7QnleWYcCdP5Hurvo7OPE9SHHcdUxX93BYAAEBlQCc3AACACmLGjBl2v2YdPny4y9YVFBSkRx55RF988YX52Pnz57Vp06Z8ZfNeHsSql33asmVLicu1aNGiwMt35HZCkoofjUKS9uzZ49C6XbUfr776avO+o/th8+bN5v3q1aurYcOGTquPs5TH7cp7udLcS5XmddVVV2nevHnmJamOHz+uwYMHO/Tli5TzvhkzZoyuvvpqzZ49WwcPHpSPj49SU1O1detWjRgxQnfeeWeZO7qVx31fWq463h3RsWNH835Bba+rlKT9d1TekSpWr17t0HPyXoatMJ7aR6VhtboeO3bMvO/ISCIbN250aLml+V/min2Tt40tTQYobypTu1wUV72vUTDa9tLL28lt/fr1Sk1NNbc1JiYm32eQyzvFFTbqW1mUh890jnDW5z4rtSfl8Ziw8vvJU/neiq+jM8+TFMdTx5QrPtsAAADAtejkBgAAUAGsW7dOEyZMMKfDw8P10EMPuXy93bt3t7u0xunTp/OVCQoKMu9fvHjR5XUqje+++04XLlwoskx2drbdic/CLgXboEED8/6uXbuKXfc333zjUB1dtR+7dOli3v/qq68c6jD10Ucfmfc7d+5sdrqykvK2XWlpaXajl+TtkJDXoEGDNG7cOHN6/fr1GjVqlEPr+L//+z9NnTpVDRs21Ny5c5WcnKykpCSlpqZq9uzZ8vPz01dffWW3H0qjvO37snDV8e6IPn36mPc//vhjt1/62JH231E333yzeX/x4sU6depUkeX379/vUEcIT++jkrBaXR3tPJtr7ty5DpUrzf8yV+ybvO3UggULlJmZWWT5Cxcu6Lvvvivzej2lMrXLRXHV+xoFo20vvdatW5sjISUlJemtt94y28wePXrkK9+1a1fzGHVVJ7fy8JnOEc763Gel9qQ8HhNWfj95Kt9b8XV05nmS4nj6mHLmZxsAAAC4Fp3cAAAAyrm5c+fqpptuMr+g9fLy0uzZs+Xv71+q5ZXkl9Tp6el2JyMLuixFRESEef+3334rVZ1c7fz583r55ZeLLPPee+/p999/N6eHDRtWYLm8nZPynuwtyFdffWV3icqiuGo/PvDAA+b9+Ph4zZgxo8jyX331ld3oLg8++KDT6uJM5W27du/ebfdFRkEjueWaMGGC+vXrZ06//fbbmjVrVpHL/+abbzR16lS1atVKmzdvVmxsrDlKgb+/vx5++GGNGTNGkvT555+XYUvK374vC1cd74546KGHFBwcLEn6/fffNWXKlDIv09ntv6Puu+8+83KKFy9e1IgRIwodUfDSpUt69NFHHRpx0BX7yFWsVtc6deqY93/66aciy37xxRdat26dQ8stzf8yV+yb+++/37x/4sSJYtvQKVOmFPslr5VVpna5KK56X6NgtO2lZ7PZ1LVrV3N66tSp5v2COq3VqFFDrVu3lpQzat62bdvMed26dXNKncrDZzpHOOtzn5Xak/J4TFj5/eSpfG/F19GZ50mK44pjylOfbQAAAOBadHIDAAAohw4fPqx3331Xbdu21QMPPGD36+dXXnlFt9xyS6mXffToUXXp0kXffvttsSObvPDCC0pNTZUk+fr62l1iI9c111xj3p8zZ46SkpJKXTdXmjJlij755JMC561evVpPPPGEOX3DDTcUegmNQYMGmfe///77QjsM/fjjjyX60thV+7FZs2a6/fbbzelnn31WX3/9dYFlN23apP/3//6fOd2mTRv179/fKfVwtvK2XXm/HPHy8jK/qCyIzWbTxx9/rKZNm5qPPfHEE/rxxx8LLJ+Zmal//OMf8vLy0ty5c1W7du0Cy1133XWSci6DWhblbd+XhauOd0fUqFHDblS/559/XhMmTCh2FITExES9/vrruuuuu/LNc3b776jq1avrueeeM6e/+eYbDR48ON978ddff1Xfvn21bt061apVq9jlumIfuYrV6pq3U8Qbb7yh3bt3F1hu+fLlJfoyszT/y1yxb1q2bGnXWfiZZ57RihUrClzOJ598UuwXvFZXmdrlorjqfY2C0baXTd73a+6IQoGBgWZeu1xu57dz586Z+6Jx48aqV6+eU+pTXj7TOcIZn/us1J6Ux2PCyu8nT+V7q76OzjpPUhxXHFPO/myzZs0a2Ww288aIrwAAAJ5RxdMVAAAAQH67du3STTfdZPfYxYsXlZiYqFOnTunMmTP5nlOrVi3Nnj3b7qRsaa1fv17r169XrVq11K9fP7Vv316NGjVSaGioLl68qF9++UWffPKJNm7caD5n5MiRqlatWr5l3XPPPZo2bZoMw1BcXJzq1auna665RtWrVzcvq9OyZUu9+OKLZa53ad155536/PPPNWTIEH3++ee68847Va9ePZ05c0bffvutPvzwQ3NkiaCgoCJHfOnbt6+io6O1b98+SdKQIUO0YsUK3XLLLQoNDdWJEyf07bff6rPPPlN2drbuu+8+hy4P6cr9OHPmTP344486ffq0MjIyNGjQIA0ePFiDBw9WvXr1dPbsWS1ZskTz5s0zTw77+/vrgw8+kLe3d4nX5y7labvydnJr0qSJ3SV8ChIaGqqvv/5aHTp00Pnz55WRkaHbb79d27ZtU2RkpF3Z5cuX69dff5W3t7fdpcMul56eLinnC9SyKk/7vixcdbw76h//+Ie2bNmiBQsWyDAMjR8/Xu+9957uuecedejQQbVq1VJmZqbOnTunPXv2aOPGjVq9erUyMjLUoUOHApfpzPa/JJ555hmtXr3a7Gj09ddf65tvvlHLli1Vq1YtxcfH65dffpGU03Hitdde09ChQyXlfBHlzn3kKlaq6yOPPKKpU6fq4sWLOn/+vK6//nqNGDFCPXr0UFBQkI4dO6aFCxdqwYIFknJGH3n33XeLXW5p/5e5Yt+88cYb+vHHH5WcnKz09HTddNNNGjJkiAYOHKiwsDCdOHFCX3zxhRYuXChJuuuuu/TZZ5+VZbd6VGVpl4viqvc1CkfbXnoFjdgWExNT6H7p3r17vlEanXWpUql8fKZzhLM+91mtPSlvx4SV30+ezPdWex2deZ6kOK46pjz12QYAAAAuZAAAAMASYmNjDUklvtWtW9d47rnnjPj4eIfW061bN/O5c+bMyTf/8OHDJa7DgAEDjLS0tELX+c9//rPI53fr1i3fc6Kiosz5q1evdnAvFr99hS3/vvvuK3Y7/f39jVWrVhVbhy1bthjBwcHFLu/pp582Vq9ebU5HRUUVudyS7kdH94VhGMa+ffuMevXqOfR6V61atdjXpKSv3+XvO2dx9nYZhlGi18xRHTt2NJd51113Ofy8BQsWGDabzXzuNddcY6SmptqVGT58eImO53vvvdcp2+Tsfe+K/Z6rtO2NYbjmeC/JsZuRkWGMHDmyxO12hw4d8i3LFe1/SaSkpBiDBw8ucn1RUVHGtm3bjKVLl5qPXXvttW7bR4bh2vbN03XN64MPPrBrXwq7denSxbh48aLdY4cPHy50uaXJBK7YN4ZhGOvWrTMCAwOLXcb999/vkjaopMssy+tpGJ7/X583677wwgvFlp8zZ06x74uScsX72lVtgquWW5L/Mc5QXtp2w7BOfjUMw8jKyjKqV69ut/xJkyYVWv6PP/7I997+6KOPil1PSd4PJW2/rbI/XfW5zwrtSV7l7ZgobR5wRFn/X3oy37vidSwJVx0vjmy/s48pZ3+2yftaO9JmAgAAwDW4XCkAAEA54OXlpdDQUEVGRqpVq1a6/fbb9fLLL2vVqlU6evSoJk6cqPDwcKesKzw8XFOnTlWXLl2KHEFByrn81TvvvKNvvvlGfn5+hZZ78cUX9cMPP+i+++5Ts2bNFBwcbP5C2yo+/PBDTZ06VTVr1ixwfpcuXbR9+3b17Nmz2GW1b99ea9assbsMS17169fXBx98oGnTppWojq7cj1dddZV27dqlxx9/vNBRxHx8fHTPPfdoz549Th0ZwpXKw3ZlZ2dr165d5nTbtm0dfu6gQYPsLmuzY8cOu8vMSTIv9fLhhx/KMIxib84aiaA87HtncNXx7qgqVaqYI1L17t27yBGXbDabrr76ak2aNElffPFFvvmuaP9LIjAwUF9++aWWLl2qO+64Q/Xr15evr6/CwsLUsWNHvfbaa4qLi1O7du2UkJBgPq+4y9s5cx+5mpXqev/99+ubb75Ro0aNCpxfvXp1/fOf/9QPP/wgf39/h5db2v9lrtg3Xbp00Y4dOwptf2rWrKmpU6fqgw8+KLZ+5UFlaZeL4qr3NQpH2146Xl5e6tq1q91jRR2TNWrUyHe5e2cfw+XhM50jnPW5z2rtSXk7Jqz8fvJkvrfa6+jM8yTFcfYx5enPNgAAAHANm2EYhqcrAQAAAGtKS0vTzp07dfDgQcXHx+vixYsKCgpSRESErr76al111VWerqLTXbp0SatXr9bvv/+upKQkhYeHq1OnTmratGmplhcXF6ctW7bojz/+UI0aNdS0aVN17drV0pf+SktL07p16/T777/r3LlzCgkJUYMGDdS9e3eFhIR4unqlVlG3qzhNmzbVwYMHtWDBAqdczrg0Ksu+t8LxnpSUpPXr1+v48eM6d+6cqlSpomrVqqlx48Zq3bp1sZ0Gclm9/R81apTeeOMNSdKYMWP08ssvO/xcZ+0jd7BCXTMzM7Vx40bt3LlTycnJqlWrlho2bKju3bsX+4WhKzl73xw8eFA//fST4uPjFRoaqkaNGqlnz54e3UZXqiztcmGs+r6u7CpL2w73atiwoY4ePSpJWr16tdn5z1mf+6zannBMOIen871VXkdnnycpiiuOKat/tgEAAIDj6OQGAAAAABVY8+bNdeDAAU2bNk1PP/20p6sDlNnFixfVoEEDnT17VpL0zTff6JZbbvFwrQAAZUHbDlcprJMbAAAAAKD84XKlAAAAAFCBtWzZUpL07rvvKi0trdBy6enpSklJcVe1gHwc+Q2eYRh67LHHzE4QYWFh6tu3r6urBgAoJdp2AAAAAADgLHRyAwAAAIAK7KGHHpIkHThwQN26ddOGDRuUkZEhKedSMLt379ZLL72kJk2aFNkJDnC1QYMG6fnnn9fu3bsLnL99+3b169dP77//vvnY2LFj5ePj464qAgBKiLYdAAAAAAA4C5crBQAAAIAKbuzYsXr55ZfN6SpVqigkJERJSUnKysqSJNWtW1cnTpzwVBUBdezYUZs3b5YkVatWTU2aNFFoaKhSUlJ06NAhJSQk2JW/+eabtXjxYtlsNk9UFwDgANp2eBqXKwUAAACAiqOKpysAAAAAAHCtKVOmqFevXpo1a5Y2bdqkhIQEpaSkqF69emrVqpVuueUWDRw40NPVRCXn5fXXYPOJiYnaunVrgeW8vb31yCOPaMaMGXSCAAAnWbFihV599dUyL+fGG2/U3//+d3Oath0AAAAAADgLndwAAAAAoBK44YYbdMMNN3i6GkChli5dqm+++UY//PCDdu7cqePHjys5OVk2m001atTQFVdcoe7duys2NlZNmzb1dHUBoEI5ceKEli9fXublRERE2E3TtgMAAAAAAGfhcqUAAAAAAAAAUInNnTtXDzzwQJmXExsbq7lz55a9QgAAAAAAAJehkxsAAAAAAAAAAAAAAAAAwLK8PF0BAAAAAAAAAAAAAAAAAAAKQyc3AAAAAAAAAAAAAAAAAIBl0ckNAAAAAAAAAAAAAAAAAGBZdHIDAAAAAAAAAAAAAAAAAFgWndwAAAAAAAAAAAAAAAAAAJZFJzcAAAAAAAAAAAAAAAAAgGXRyQ0AAAAAAAAAAAAAAAAAYFl0cgMAAAAAAAAAAAAAAAAAWBad3AAAAAAAAAAAAAAAAAAAlkUnNwAAAAAAAAAAAAAAAACAZdHJDQAAAAAAAAAAAAAAAABgWXRyAwAAAAAAAAAAAAAAAABYFp3cAAAAAAAAAAAAAAAAAACWRSc3AAAAAAAAAAAAAAAAAIBl0ckNAAAAAAAAAAAAAAAAAGBZdHIDAAAAAAAAAAAAAAAAAFgWndwAAAAAAAAAAAAAAAAAAJZFJzcAAAAAAAAAAAAAAAAAgGXRyQ0AAAAAAAAAAAAAAAAAYFl0cgMAAAAAAAAAAAAAAAAAWBad3AAAAAAAAAAAAAAAAAAAlkUnNwAAAAAAAAAAAAAAAACAZdHJDQAAAAAAAAAAAAAAAABgWXRyA1ApZWZm6quvvtIjjzyiVq1aKSwsTD4+PgoNDVXjxo01aNAgTZs2TYcPHy50GQ0bNpTNZlPDhg2LXd/o0aNls9lks9nUpEkTHT9+3Jw3bNgwc96RI0ecsHUAAAAVmzOz3OU3Hx8f1apVS507d9b48eN18uRJN24ZAACA67gyQxV2q1atWr5lrFmzptDygYGBioqK0q233qr58+crMzPTqfsgOztb+/bt09y5c/W3v/1N7du3l5+fn7n+NWvWOHV9AAAAjiKrSampqVqwYIFGjBih9u3bq3r16vLx8VHNmjUVExOj8ePHKz4+3qnrBFC+2AzDMDxdCQBwp0WLFunvf/+7fvvtN4fK9+vXTy+//LJatmxp93jDhg119OhRRUVFFdo5zTAMPf7443rjjTckSc2bN9eqVatUt25ds8ywYcM0b948SdLhw4cd6jQHAABQWTk7yxUnJCREc+fO1aBBg0pVXwAAACtwd4bKFRoaqsTERLvH1qxZox49ejj0/Pbt22vRokWKiIhweJ1FmTdvnoYNG1bo/NWrV6t79+5OWRcAAICjyGrSrl271KlTJ124cKHIciEhIZo9e7buuuuuMq8TQPlTxdMVAAB3evHFF/X8888rt39v9+7d1b9/f7Vu3Vo1a9ZUamqqTp06pXXr1mnx4sU6cuSIvvvuO9WvX19vvfVWidZlGIaGDx+u2bNnS5JatGihVatWKTw83OnbBQAAUBm4IsvVrVtXy5cvN6czMjJ05MgRzZkzR99++62Sk5N19913a9OmTbr66qvdsp0AAADO5I4MVRhvb+8i548YMUJ/+9vfzOkLFy5o27ZtevXVV3XkyBFt3bpVAwcO1KZNm2Sz2Uqw1QXL+5t/Hx8ftWrVShkZGdq9e3eZlw0AAFAaZLUcycnJZge3Tp06qX///rr22mtVs2ZNnTlzRgsWLNA777yj5ORk3XvvvQoJCVHfvn3LtE4A5Q+d3ABUGu+//76ee+45SVJ4eLg+/fTTQn+Zeccdd2j69On69NNP9eyzz5Z4XdnZ2XrooYc0Z84cSVKbNm20cuVK1apVq9T1BwAAqMxcleV8fHzy/er16quv1qBBg/T3v/9dr732mi5duqQXX3xRX331lVO2BQAAwF3cmaFKIywsLN9yOnbsqHvvvVfXXXedfvvtN23ZskWLFy/WgAEDyry+6Ohovf7662rfvr3atm0rf39/jR8/nk5uAADAI8hqf/Hy8tKdd96pF154QdHR0fnm9+7dW3379tWgQYOUlZWlUaNG6eDBg075IQSA8sPL0xUAAHc4fvy4Ro4cKSlnGNv169cXe+kBb29v3Xvvvdq5c6f69evn8LqysrIUGxtrdnBr166dVq9eTQc3AACAUnJnlstrwoQJCggIkCR9//33ys7OLtVyAAAAPMFTGcoZqlevrrFjx5rTy5Ytc8pyr7vuOo0aNUodO3aUv7+/U5YJAABQGmQ1e9dff70+++yzAju45Ro4cKBuu+02SdKhQ4f0888/l3m9AMoXOrkBqBRee+01paWlSZImT56sxo0bO/zcatWqOfzrg8zMTN1777366KOPJOX8mmHVqlWqXr16ySsNAAAASe7LcpcLDg42T6xduHBB586dK9VyAAAAPMFTGcpZrrvuOvP+0aNHPVgTAAAA5yOrlU6PHj3M+4cOHXLbegFYA5crBVDhGYahDz/8UJJUtWpVPfDAAy5ZT0ZGhu6++24tWLBAktS5c2ctWbJEVatWdcn6AAAAKgN3ZbnC+Pj4mPezsrLcum4AAIDS8nSGcgZyGAAAqKjIaqWXnp5u3vf29nbbegFYAyO5Aajw9uzZoz/++EOS1KVLFwUFBTl9HZcuXdLtt99udnDr0aOHli1bRgc3AACAMnJHlitMZmam9u/fL0ny9fVVzZo13bZuAACAsvBkhnKW3bt3m/fr1q3rwZoAAAA4F1mt9NauXWvev+qqq9y2XgDWwEhuACq8Xbt2mfevueYapy8/IyNDgwYN0pIlSyRJN954o7755hsFBAQ4fV0AAACVjauzXFHefvttJSYmSsoZpbdKFT5CAwCA8sEd58P27NlTbLmwsDCFhYWVePmZmZl69dVXzenu3buXeBkAAABWRVYrnZ07d+q7776TJLVq1YpObkAlxBl6ABXe2bNnzfu1a9cutFx2drb27dtX6PxmzZrZDb2b6+TJkzp58qQkqVu3blq0aJH8/f3LUGMAAADkcnWWu1xmZqaOHDmiOXPm6JVXXjEff+aZZxysMQAAgOe543xYq1atiq3HCy+8oPHjxxdbLldKSoq2bdum8ePHa9OmTZKkqKgo3XnnnQ4vAwAAwOrIaiWXnp6uhx56yLw06uTJk12+TgDWQyc3ABXe+fPnzftFDfebnJxcZOA7fPiwGjZsmO9xm80mwzAk5QzN++uvv6p169alrzAAAABMrs5yR48elc1mK/R5NptNkyZN0k033eRYhQEAACzA1RnKWSZMmKAJEyYUOj8sLExff/21/Pz8XFYHAAAAdyOrldxjjz2mbdu2SZJiY2M1YMAAl68TgPXQyQ1AhVe1alXzfkpKitOX36BBA915552aNm2azp07pxtvvFFr165V8+bNnb4uAACAysbVWa4wISEh6tmzp0aPHq0uXbq4bb0AAADO4OoMFRUVpSNHjjh9ubkaNWqk22+/XU8//XSpLqEFAABgZWS1kpkyZYreffddSVL79u01c+ZMl68TgDXRyQ1AhVezZk3z/pkzZwotV61aNXNEtlzDhg3TvHnzil3H1KlTdfHiRb3xxhtKSEhQr169tG7dOl1xxRWlrzgAAABcnuXq1q2r5cuXm9NVqlRRaGioIiIiihzhDQAAwMrccT7MGUaMGKG//e1vknJG0PX391etWrUUGhrqlvUDAAB4AlnNcW+//baeffZZSVLz5s21ZMmSIke/A1Cx0ckNQIXXpk0b8/7PP//ssvW8/vrrSk1N1fvvv68TJ07ohhtu0Lp16xQZGemydQIAAFR0rs5yPj4+atmypdOXCwAA4EnuOh9WVmFhYWQxAABQ6ZDVHPPJJ5+YneyioqK0YsUK1apVy2P1AeB5Xp6uAAC4WsuWLc1fRPz4449KTU11yXpsNpveeecdDRkyRJJ05MgR3XDDDYqPj3fJ+gAAACoDd2U5AACAioQMBQAAYF1kteItWrRIQ4cOVXZ2turUqaNVq1apfv36nq4WAA+jkxuACs9ms+m+++6TJCUnJ7t0CF8vLy/NmzdPt912myTp4MGD6tWrl/744w+XrRMAAKAic2eWAwAAqCjIUAAAANZFVivaqlWrdOeddyozM1M1a9bUihUrdOWVV3q6WgAsgE5uACqF0aNHy9/fX5I0duxYHT582GXrqlKlij755BP17dtXkrR371717t1bSUlJLlsnAABARebOLAcAAFBRkKEAAACsi6xWsA0bNmjgwIFKT09XaGioli9frhYtWni6WgAsgk5uACqFBg0a6PXXX5ckJSUlqXPnzlq/fn2RzzEMQ4mJiaVan6+vrxYsWKCePXtKknbs2KGbbrpJFy5cKNXyAAAAKjN3ZzkAAICKgAwFAABgXWS1/OLi4tSvXz+lpKQoKChI3333ndq1a+fpagGwkCqergAAuMvDDz+sEydOaMKECTp58qS6dOminj17asCAAWrVqpVq1KihrKwsxcfHa8eOHfr888+1d+9eSZK3t7d8fX1LtD5/f38tWrRIffr00U8//aRNmzapf//+Wrp0qQICAgp8zpdffqlatWoVuVxfX18NGTKkRHUBAAAo79yd5QAAACoCV2WojIwM7dmzx6E6NG7c2BylxArmzp1rNx0XF2feX7ZsmY4cOWJON27cWJ07d3ZPxQAAQKVDVvvLoUOH1KdPH7MT34svvqjQ0NAityMsLExhYWFuqiEAK7AZhmF4uhIA4E4LFy7U008/rd9//73YsjabTX369NG0adPUsmVLu3kNGzbU0aNHFRUVZXfy63LJycm64YYbtG3bNklSnz59tGjRIjN4Dhs2TPPmzXO4/qGhoRX6VxoAAABFcXeWAwAAqAicnaFK4ueff1bbtm3N6TVr1qhHjx6SpBdeeEHjx48v0fLKymazOVw2NjY2X6c4AAAAZyOr5fwQ4YEHHijRczyRJQF4FiO5Aah0Bg0apAEDBmjhwoVavny5Nm7cqISEBCUmJiowMFA1a9ZUq1atFBMTo7vuukuNGjUq0/pCQkK0fPly9ejRQ7t27dLy5ct111136YsvvlCVKjTDAAAAJeHuLAcAAFARkKEAAACsi6wGAI5hJDcAAAAAAAAAAAAAAAAAgGV5eboCAAAAAAAAAAAAAAAAAAAUhk5uAAAAAAAAAAAAAAAAAADLopMbAAAAAAAAAAAAAAAAAMCyqni6AgAAAAAAAAAAAEVJSEhQQkJCiZ/n6+urpk2buqBGAAAAyEVWA+AOdHIDAAAAAAAAAACW9uabb2rChAklfl5UVJSOHDni/AoBAADARFYD4A5crhQAAAAAAAAAAAAAAAAAYFk2wzAMT1fC07Kzs3Xy5ElVrVpVNpvN09UBAACVjGEYOn/+vOrWrSsvL36DkBc5DQAAeBpZrXBkNQAA4EnktMKR0wAAgKe5IqtxuVJJJ0+eVGRkpKerAQAAKrnjx4+rfv36nq6GpZDTAACAVZDV8iOrAQAAKyCn5UdOAwAAVuHMrObRTm6zZs3SrFmzzGsst2jRQs8//7z69u0rSerevbvWrl1r95xHH31Ub731ljl97NgxjRgxQqtXr1ZwcLBiY2M1ZcoUVani+KZVrVpVUs6ODQkJyV8gJUWqWzfn/smTUlBQCbYSAACgaMnJyYqMjDQzCf5SbE4rChkOAAA4AVmtcGXKashBZgUAoNTIaYUjpzkBOQ0AgDJxRVbzaCe3+vXr6+WXX1aTJk1kGIbmzZungQMH6ueff1aLFi0kSQ8//LAmTpxoPicwMNC8n5WVpX79+ikiIkIbNmzQqVOnNHToUPn4+Oill15yuB65w/SGhIQUHPS8vf+6HxJCiAEAAC7BpQPyKzanFYUMBwAAnIisll+ZshpykFkBACgzclp+5DQnIKcBAOAUzsxqHu3kNmDAALvpyZMna9asWdq0aZPZyS0wMFAREREFPv/777/Xvn37tHLlSoWHh6tt27aaNGmSxowZo/Hjx8vX19fl2wAAAAAAAAAAAAAAAAAAcB0vT1cgV1ZWlj799FOlpKQoJibGfPzjjz9WrVq11LJlS40dO1apqanmvI0bN6pVq1YKDw83H+vTp4+Sk5O1d+/eQteVnp6u5ORkuxsAAAAAAAAAAAAAAAAAwHo8OpKbJO3evVsxMTFKS0tTcHCwFi5cqOjoaEnSkCFDFBUVpbp162rXrl0aM2aMDhw4oAULFkiS4uPj7Tq4STKn4+PjC13nlClTNGHCBBdtEQAAAAAAAAAAAAAAAADAWTzeya1Zs2aKi4tTUlKSvvzyS8XGxmrt2rWKjo7WI488YpZr1aqV6tSpoxtuuEGHDh3SlVdeWep1jh07VqNHjzank5OTFRkZWfgTqlSR/va3v+4DAADA+shwAAAAsDoyKwAAgDWR0wAAsByP/0f29fVV48aNJUnt2rXT1q1bNWPGDL399tv5ynbo0EGS9Ntvv+nKK69URESEtmzZYlfm9OnTkqSIiIhC1+nn5yc/Pz/HK+nnJ82c6Xh5ALCYjIwMZWVleboaQKXk4+Mjb29vT1ejciLDASgHyGmA53h7e8vHx8fT1UBlR2YFLCsrK0sZGRmergZQaXFODR5HTgMsjawGeI4nz6l5vJPb5bKzs5Wenl7gvLi4OElSnTp1JEkxMTGaPHmyEhISFBYWJklasWKFQkJCzEueAkBllpycrLNnzxbargJwPZvNptDQUEVERMhms3m6OgAAiyCnAdbg5+enWrVqKSQkxNNVAQBYhGEYio+PV1JSkgzD8HR1gEqLc2oAgIKQ1QBr8NQ5NY92chs7dqz69u2rBg0a6Pz585o/f77WrFmj5cuX69ChQ5o/f75uvvlm1axZU7t27dJTTz2lrl27qnXr1pKk3r17Kzo6Wvfff7+mTp2q+Ph4jRs3TiNHjizZSG3FMQzp7Nmc+7VqSYRpAOVAcnKyTpw4oeDgYNWqVUs+Pj6cDADczDAMpaSk6MyZMwoICFC1atU8XaXKhQwHwKLIaYDnGYahjIwMJSUl6cSJE5JERzd4BpkVsJykpCQlJiaqdu3aCgoKIqcBHsA5NVgCOQ2wJLIa4FmePqfm0U5uCQkJGjp0qE6dOqXQ0FC1bt1ay5cv14033qjjx49r5cqVmj59ulJSUhQZGanBgwdr3Lhx5vO9vb21ePFijRgxQjExMQoKClJsbKwmTpzo3Iqmpkr/GylOFy5IQUHOXT4AuMDZs2cVHBys+vXrE/AADwoICFB6eroSEhIUGhrK8ehOZDgAFkVOA6whICBAVatW1X//+1+dPXuWTm7wDDIrYCmGYSghIUEhISGqVauWp6sDVGqcU4PHkdMAyyGrAdbgyXNqHu3k9t577xU6LzIyUmvXri12GVFRUVqyZIkzqwUA5V5GRobS09NVq1YtPvwDFhASEqLk5GRlZWWpShXLXS0eAOBG5DTAWnIvg3XixAllZGTIx8fH01UCAHhQVlaWsrKy6PgMWATn1AAAeZHVAOvw1Dk1L7esBQDgVllZWZLEFzSAReSehMvMzPRwTQAAnkZOA6wn93jMPT4BAJVX7ud2OtMA1sA5NQBAXmQ1wFo8cU6NTm4AUIExOghgDRyLAIDL8b8BsA6ORwDA5fjfAFhDeTwWZ82apdatWyskJEQhISGKiYnR0qVLzfndu3eXzWazuw0fPtxuGceOHVO/fv0UGBiosLAwPfPMM3T0A4A8yuP/B6Ai8sSxSBdXAAAAAAAAAAAAACij+vXr6+WXX1aTJk1kGIbmzZungQMH6ueff1aLFi0kSQ8//LAmTpxoPicwMNC8n5WVpX79+ikiIkIbNmzQqVOnNHToUPn4+Oill15y+/YAAABYCZ3cAAAAAAAAAAAAAKCMBgwYYDc9efJkzZo1S5s2bTI7uQUGBioiIqLA53///ffat2+fVq5cqfDwcLVt21aTJk3SmDFjNH78ePn6+rp8GwAAAKyKy5UCAAAAAAAAAAAAgBNlZWXp008/VUpKimJiYszHP/74Y9WqVUstW7bU2LFjlZqaas7buHGjWrVqpfDwcPOxPn36KDk5WXv37i10Xenp6UpOTra7AQAAVDR0cnNElSpSbGzOrQqD3wEAKoa5c+fKZrPpyJEjnq4K4BpkOABAOUVOAyoRMisAlCvkNDhi9+7dCg4Olp+fn4YPH66FCxcqOjpakjRkyBB99NFHWr16tcaOHasPP/xQ9913n/nc+Ph4uw5ukszp+Pj4Qtc5ZcoUhYaGmrfIyEgXbFklQ04DgHKHrFbx0cnNEX5+0ty5OTc/P0/XBgCgv0JK7s3f319NmzbVY489ptOnT3u6ekXasGGDxo8fr8TERIfKX76tVapUUb169TRs2DCdOHHCtZV1wMGDOTdJWr58uWw2mz766CO7MhcuXFD//v3l7e2t119/3el1SE9P15gxY1S3bl0FBASoQ4cOWrFihUPP3bt3r+644w5dccUVCgwMVK1atdS1a1d9++23pSoHCyHDAYBHXJ5d/Pz81agROc3TKnJOu9zkyZNls9nUsmVLZ2wC4FpkVgBuVF7Op+U915SLnFZ+c9r27dt10003KSQkRFWrVlXv3r0VFxfn5K2xlmbNmikuLk6bN2/WiBEjFBsbq3379kmSHnnkEfXp00etWrXSvffeqw8++EALFy7UoUOHyrTOsWPHKikpybwdP37cGZtSuZHTALhZeclqeeXmNrIaWc1d6HYOACjXJk6cqEaNGiktLU3r16/XrFmztGTJEu3Zs0eBgYGerl6BNmzYoAkTJmjYsGGqVq2aw8/Lu62bNm3S3LlztX79eu3Zs0f+/v6uq3AJ7Ny5U5LUpk0b87ETJ06of//+OnjwoBYuXKhbbrnF6esdNmyYvvzySz355JNq0qSJ5s6dq5tvvlmrV69W586di3zu0aNHdf78ecXGxqpu3bpKTU3VV199pVtuuUVvv/22HnnkkRKVAwCgssj94rFJk4Ln52aXo0fTtH07Oc3TKnJOy+u///2vXnrpJQUFBTl9WwAAqCg4n0ZOk9yT03bs2KHOnTsrMjJSL7zwgrKzs/Xmm2+qW7du2rJli5o1a+b07bICX19fNW7cWJLUrl07bd26VTNmzNDbb7+dr2yHDh0kSb/99puuvPJKRUREaMuWLXZlcjs2REREFLpOPz8/+dERCwAqBLIaWU0iqxXKgJGUlGRIMpKSkgoukJ1tGBcu5Nyys91bOQAohYsXLxr79u0zLl686OmquMycOXMMScbWrVvtHh89erQhyZg/f36Z13HhwoUyL6Mg06ZNMyQZhw8fdqh8Yds6ZswYQ5Lx2Weflaoeuct1tB6F+fXXnJthGMa9995r+Pr6GpcuXTIMwzDi4uKMevXqGXXq1DG2bdtWpvUUZvPmzYYkY9q0aeZjFy9eNK688kojJiamVMvMzMw02rRpYzRr1swp5Yo7JovNIpVYmfYNGQ6ABVWknJY3A+R1eXbJLUdOc5yzclpelSWn3XXXXUbPnj2Nbt26GS1atHBomWS10mPfOAGZFbCUipTVClJezqcVlDPJac7lrpx28803G9WrVzfOnj1rPnby5EkjODjYuO2224pdZkXJaT169DBiY2MLnLd+/XpDkrFz507DMAxjyZIlhpeXl3H69GmzzNtvv22EhIQYaWlpDq+zvOwbSyOnAZZDVrNGVssrN7eR1ZyLrFY4LlfqiNRUKTg455aa6unaAACK0LNnT0nS4cOHJeX0VP/b3/6mZs2aKSAgQDVr1tQdd9yR71rs48ePl81m0759+zRkyBBVr17drhf8iRMn9P/+3/9TeHi4/Pz81KJFC73//vsFLuO3334zf6kQGhqqBx54QKn/+/8xfvx4PfPMM5KkRo0amcPwluba8F26dJGkfEPZDxs2TA0bNsxXPrd+xXFkWwuzc+dOXXXVVfLx8dGSJUvUuXNnVa9eXZs2bVK7du0cWkau/fv369ixY8WW+/LLL+Xt7W03koe/v78efPBBbdy4sVRD83t7eysyMrLYYZUdLQcPIcMBgKWQ08hpkmtz2rp16/Tll19q+vTpJV4u4DFkVgAWYLWcds01ofq//yOnVYSc9uOPP6pXr16qWbOm+VidOnXUrVs3LV68WBcuXCjxeqxu7NixWrdunY4cOaLdu3dr7NixWrNmje69914dOnRIkyZN0vbt23XkyBEtWrRIQ4cOVdeuXdW6dWtJUu/evRUdHa37779fO3fu1PLlyzVu3DiNHDmSkdrcjZwGwCKsltUuP6f2+utkNUeR1cqOy5UCACqU3NCT+89469at2rBhg+6++27Vr19fR44c0axZs9S9e3ft27cv37C+d9xxh5o0aaKXXnpJhmFIyhkOvmPHjrLZbHrsscdUu3ZtLV26VA8++KCSk5P15JNP2i3jzjvvVKNGjTRlyhTt2LFD7777rsLCwvTKK6/otttu06+//qpPPvlE//73v1WrVi1JUu3atUu8rbnhsHr16iV+bmFKuq15Xbp0SQcOHNA999yjN998U48//rh69uypL7/8UiEhISWuy1VXXaVu3bppzZo1RZb7+eef1bRp03zruO666yRJcXFxioyMLHZ9KSkpunjxopKSkrRo0SItXbpUd911V6nLAQAAe+S0siGnFZ2/srKyNGrUKD300ENq1apVyTYIAIBKzmo5bfXqHfrii3fVuDE5raSsltPS09MVEBCQ73mBgYG6dOmS9uzZo44dOzqwZeVHQkKChg4dqlOnTik0NFStW7fW8uXLdeONN+r48eNauXKlpk+frpSUFEVGRmrw4MEaN26c+Xxvb28tXrxYI0aMUExMjIKCghQbG6uJEyd6cKsAAJ5ktayW95zaQw+9ot69b9Mff5DVHEFWKzs6uQFAZZSSUvg8b28p7zXOiyrr5SXl/cdXkrJOkpSUpLNnzyotLU0//fSTJk6cqICAAPXv31+S1K9fP91+++12zxkwYIBiYmL01Vdf6f7777eb16ZNG82fP9/usX/+85/KysrS7t27zQA5fPhw3XPPPRo/frweffRRuwBw9dVX67333jOn//jjD7333nt65ZVX1Lp1a11zzTX65JNPdOuttxb4qwNHtnXz5s2aMGGC/Pz8zG11hpJua1779u1TRkaGVq9erQ8++EAPPfSQZs2apSpVXBs3Tp06pTp16uR7PPexkydPOrScv//973r77bclSV5eXrrtttv0xhtvlLocAAClUgFzWnx8mrZv/0kvvkhOKwtyWtH566233tLRo0e1cuXKMtYaAIAiVJCsZvXzab16SYmJ5DRXcldOa9asmTZt2qSsrCx5e3tLyvmyePPmzZJyRlWpaPJ+3rhcZGSk1q5dW+wyoqKitGTJEmdWCwAqPivktNRU6bIOZqVh9awm/XVO7aGHXlHz5mQ1ZyOrFY7LlQJAZZQ7xHZBt8GD7cuGhRVetm9f+7INGxZetmtXl2xKr169VLt2bUVGRuruu+9WcHCwFi5cqHr16kmSXSjJyMjQH3/8ocaNG6tatWrasWNHvuUNHz7cbtowDH311VcaMGCADMPQ2bNnzVufPn2UlJSUbzmXL6NLly76448/lJyc7LRtvf322xUUFKRFixapfv36ZVpurtJsa167du2SJCUmJiogIEDPPfdcmUKeYRjF/pJBki5evFjgUP3+//vAcvHiRYfW9+STT2rFihWaN2+e+vbtq6ysLF26dKnU5QAAKJUKmNO6do3UU0+R08qCnFZ0/vrjjz/0/PPP67nnnivVr4QBAHBYBclq5eF82rXXFpzTDh+WDh4s3baS0/7irpz2t7/9Tb/++qsefPBB7du3T3v27DFHOSvJegAAKJYVclp0tFM2pTxktdxzahcucE6tpPUhq5UNI7kBAMq1mTNnqmnTpqpSpYrCw8PVrFkzeXn91Yf74sWLmjJliubMmaMTJ06Yw/BKOb8OuFyjRo3sps+cOaPExETNnj1bs2fPLrAOCQkJdtMNGjSwm84dUvfPP/8s1dC1uXK3NSkpSe+//77WrVtXYMAprdJsa147d+6UJH3zzTfq37+/br/9dq1fv16+vr5Oq2NBAgIClJ6enu/xtLQ0c74jmjdvrubNm0uShg4dqt69e2vAgAHavHmzbDZbicsBAFDZ5WaX+PgqqlkzXFdcQU4rLXJa0flr3LhxqlGjhkaNGuW8ygMAUIGVh/NpoaHkNFdyV04bPny4jh8/rmnTpmnevHmSpGuvvVb/+Mc/NHnyZAUHBztpiwAAqDjKQ1bLPaeWlPSngoPJas5GViscndwAoDK6cKHwef8bitRUxD92eV02IOj/rpPuUFknue6663TttdcWOn/UqFGaM2eOnnzyScXExCg0NFQ2m0133323srOz85W/PBTklrnvvvsUGxtb4Dpat25tN+19+T78n7whszTybuutt96qzp07a8iQITpw4IBdyCiso1VWVlaRyy/Ntua1a9cuRUREqEePHpo1a5ZiY2P1xBNPaNasWUWut6zq1KlT4HC5ub8yqFu3bqmWe/vtt+vRRx/Vr7/+qmbNmpW5HAAADqmAOa2wkTbIaX8hp5VM3vzl5eWl2bNna/r06XaXakhLS1NGRoaOHDmikJAQ1ahRo3QbAQBAXhUkq3E+jZzmzvNpkydP1tNPP629e/cqNDRUrVq10rPPPitJatq0aSm3AACAy1ghp+3bV3jZEiCrkdXIaoWjkxsAVEZBQZ4v6yZffvmlYmNj9eqrr5qPpaWlKTEx0aHn165dW1WrVlVWVpZ69erllDo5Y7Qvb29vTZkyRT169NAbb7yh//u//zPnVa9evcDtO3r0aJHLLOu27tq1S23btpWU82uA9evX66233tL111+v+++/365sdna2pk+frrfeektnz57VwIEDNXv2bPn4+JR4vW3bttXq1auVnJxs98ve3OvF59appHKH4C3oVy+lKQcAgEPIaeS0ApDT7OXNX6mpqcrOztbjjz+uxx9/PF/ZRo0a6YknntD06dNLtS4AAOxUkqxGTvsLOa1kCjtPVr16dXXu3NmcXrlyperXr2+OLAIAQJlZIacFBjpetgzIan8hq5VMRchqrvm5dkXj7S3dfnvOrZAeqgAAa/L29s73K4L//Oc/xfbsz/v8wYMH66uvvtKePXvyzT9z5kyJ6xT0v0DsaNgsTPfu3XXddddp+vTp5vC0knTllVcqKSnJvE68lNOzf+HChUUuryzbeuZMvBISEux+7fD666/r6quv1vDhw7V792678s8//7wWL16sNWvW6OjRozp8+LDef/99uzL79+/XsWPHiqyzlPOrg6ysLLthhtPT0zVnzhx16NBBkZGRkqTU1FTt379fZ8+etXt+QcMQZ2Rk6IMPPlBAQICio6NLVA4WQoYDAEsjp+VwdU6Lj6/YOa1ly5ZauHBhvluLFi3UoEEDLVy4UA8++GCxdQU8hswKwIKsnNOSkxNL/Ny8yGk53HU+rSCfffaZtm7dqieffNLu0muA5ZDTAFiUlbMa59TIaq7GSG6O8PeXvvjC07UAAJRC//799eGHHyo0NFTR0dHauHGjVq5cqZo1azq8jJdfflmrV69Whw4d9PDDDys6Olrnzp3Tjh07tHLlSp07d65EdWrXrp0k6Z///Kfuvvtu+fj4aMCAAWYALIlnnnlGd9xxh+bOnavhw4dLku6++26NGTNGgwYN0uOPP67U1FTNmjVLTZs21Y4dO1yyrfv351yTPm/Q8/f315dffql27dpp8ODB2rZtm0JCQnTq1CnNmDFDBw8eVEREhFnn7du32y3zqquuUrdu3bRmzZoi69yhQwfdcccdGjt2rBISEtS4cWPNmzdPR44c0XvvvWeW27Jli3r06KEXXnhB48ePNx9/9NFHlZycrK5du6pevXqKj4/Xxx9/rP379+vVV181h0N2tBwshAwHAJZGTnNPTtu5s2LntODgYN1666351p07cltB8wBLIbMCsCAr57R///uf6tfvbkVGktOsntMkad26dZo4caJ69+6tmjVratOmTZozZ45uuukmPfHEE0XWEfA4choAi7JyVuOcGlnN1ejkBgCo0GbMmCFvb299/PHHSktLU6dOnbRy5Ur16dPH4WWEh4dry5YtmjhxohYsWKA333xTNWvWVIsWLfTKK6+UuE7t27fXpEmT9NZbb2nZsmXKzs7W4cOHSxX0brvtNl155ZX617/+pYcfflje3t6qWbOmFi5cqNGjR+sf//iHGjVqpClTpujgwYPFBr3SbuuBAzm/nLj8uvVXXHGF5s6dq0GDBik2NlYLFy7UypUrlZaWZjfEbVZWlhlUS+ODDz7Qc889pw8//FB//vmnWrdurcWLF6tr167FPveuu+7Se++9p1mzZumPP/5Q1apV1a5dO73yyiu65ZZbSlwOAAA4hpzmnpyW+wvXipzTAACAc1k5p73xxlv68ce/ctrJkzk5rUkTx5dFTsvhjpxWr149eXt7a9q0aTp//rwaNWqkF198UaNHj1aVKnxFCQBAaVg5q3FOjazmajbj8nEMK6Hk5GSFhoYqKSnJ7nq2yM9ms2nhwoX8EhqwuLS0NB0+fFiNGjWSv7+/p6uDCu7gwZy/jp5MnDFjhnbv3q13333XdZWymOKOSbJI4dg3jiOnAeVDRcppjmaA3HK5SvIFJNyrMuY0iaxWFuwbx5HVgPKhImW18qyonHn5vJKelyqvyGnktJJi3ziOnAaUH2Q166ksWaw4ZDX3ZTXrXUDVilJSJJst55aS4unaSMoJXEXd8g5FeLkjR47IZrMpLi7OJXWLj4/XqFGjdMUVV8jPz0+RkZEaMGCAVq1a5ZL1FcVms+nrr78u8fNOnTqlIUOGqGnTpvLy8tKTTz5ZYLkvvvhCzZs3l7+/v1q1aqUlS5bYzTcMQ88//7zq1KmjgIAA9erVSwcv+4bn3LlzuvfeexUSEqJq1arpwQcf1IULF+zK7Nq1S126dJG/v78iIyM1derUEm8TAFhF27ZttWzZMu3fv1+S9Mcff2j58uUerhUqJA9lOHKaY8hpQMV38GD+Dm6wNnIaKgPLZbU8mTX+99/Jav9DVgMAe+Q0VAbkNMeQ0wDAeshq7kMnt3Lq1KlT5m369OnmdX5zb08//bRH6nXkyBG1a9dOP/zwg6ZNm6bdu3dr2bJl6tGjh0aOHOmROpVGenq6ateurXHjxqlNmzYFltmwYYPuuecePfjgg/r5559166236tZbb9WePXvMMlOnTtXrr7+ut956S5s3b1ZQUJD69OmjtLQ0s8y9996rvXv3asWKFVq8eLHWrVunRx55xJyfnJys3r17KyoqStu3b9e0adM0fvx4zZ4923U7AABcqFu3bho1apRuvPFGBQcH67rrrrNrO4HyjpzmWuQ0AHAdchoqA8tmNUntOncmq/0PWQ0A7JHTUBmQ01yLnAYArkNWcyMDRlJSkiHJSEpKKrjAhQuGIeXcLlxwb+UcMGfOHCM0NNSczsrKMiZMmGDUq1fP8PX1Ndq0aWMsXbrUnC/J7tatWzfDMAxjy5YtRq9evYyaNWsaISEhRteuXY3t27fbrUuSsXDhwkLr0rdvX6NevXrGhQL2059//mneP3r0qHHLLbcYQUFBRtWqVY077rjDiI+PN+fHxsYaAwcOtHv+E088YdbVMAyjW7duxqhRo4xnnnnGqF69uhEeHm688MIL5vyoqCi77YyKiiq03kXp1q2b8cQTT+R7/M477zT69etn91iHDh2MRx991DAMw8jOzjYiIiKMadOmmfMTExMNPz8/45NPPjEMwzD27dtnSDK2bt1qllm6dKlhs9mMEydOGIZhGG+++aZRvXp1Iz093SwzZswYo1mzZqXaHlQOFy9eNPbt22dcvHjR01VBJfDrrzk3FK64Y7LYLFKJlWnfWCDDkdPIacDlKlJOKy4D5M6//AZYDVmt9Mr7vrFEVvtfZu0rGfXq1iWrGWQ1eFZFymrlWVG58fJ5ZMyKjZxWeuV935DTyGlAQchq1kMWq9w8kdUYya0CmjFjhl599VX961//0q5du9SnTx/dcsst5lCxW7ZskSStXLlSp06d0oIFCyRJ58+fV2xsrNavX69NmzapSZMmuvnmm3X+/HmH1nvu3DktW7ZMI0eOVFBQUL751apVkyRlZ2dr4MCBOnfunNauXasVK1bo999/11133VXibZ03b56CgoK0efNmTZ06VRMnTtSKFSskSVu3bpUkzZkzR6dOnTKnc4csXrNmTYnXl9fGjRvVq1cvu8f69OmjjRs3SpIOHz6s+Ph4uzKhoaHq0KGDWWbjxo2qVq2arr32WrNMr1695OXlpc2bN5tlunbtKl9fX7v1HDhwQH/++WeZtgEAALgXOY2cBgAArMtjWU3SMkkjH3mErCayGlDZcHl7AI4gp5HTAACQpCqergCc71//+pfGjBmju+++W5L0yiuvaPXq1Zo+fbpmzpyp2rVrS5Jq1qypiIgI83k9e/a0W87s2bNVrVo1rV27Vv379y92vb/99psMw1Dz5s2LLLdq1Srt3r1bhw8fVmRkpCTpgw8+UIsWLbR161a1b9/e4W1t3bq1XnjhBUlSkyZN9MYbb2jVqlW68cYbze2sVq2a3Xb6+PioWbNmCgwMdHg9BYmPj1d4eLjdY+Hh4YqPjzfn5z5WVJmwsDC7+VWqVFGNGjXsyjRq1CjfMnLnVa9evUzbAQAA3IecRk4DAADW5bGsppyhOJo3bVpkObIaWQ0AgMqKnEZOAwBAkhjJrYJJTk7WyZMn1alTJ7vHO3XqpF9++aXI554+fVoPP/ywmjRpotDQUIWEhOjChQs6duyYQ+s2DMOhcr/88osiIyPNkCdJ0dHRqlatWrF1vFzr1q3tpuvUqaOEhIQin1OvXj3t379f1113XYnWBQAAUBbkNHIaUFEdPFiyEThKWh4A3MGjWc3BOpLVAABAZUROI6cB8BzO48Fq6OQGU2xsrOLi4jRjxgxt2LBBcXFxqlmzpi5duuTQ85s0aSKbzab9+/eXuS5eXl75vozNyMjIV87Hx8du2mazKTs7u8zrd0RERIROnz5t99jp06fNX07k/i2uzOXBNDMzU+fOnbMrU9Ay8q4DAABUbOS0kiGnAQAqulmzZql169YKCQlRSEiIYmJitHTpUnN+WlqaRo4cqZo1ayo4OFiDBw/O9z/r2LFj6tevnwIDAxUWFqZnnnlGmZmZ7t6UCqHMWU2STdL+X38tc13IamQ1AADwF3JayZDTAABWRyc3R3h7SzffnHPz9vZ0bYoUEhKiunXr6qeffrJ7/KefflJ0dLQkmdc3z8rKylfm8ccf180336wWLVrIz89PZ8+edXjdNWrUUJ8+fTRz5kylpKTkm5+YmChJuuqqq3T8+HEdP37cnLdv3z4lJiaadaxdu7ZOnTpl9/y4uDiH65LLx8cn33Y6S0xMjFatWmX32IoVKxQTEyNJatSokSIiIuzKJCcna/PmzWaZmJgYJSYmavv27WaZH374QdnZ2erQoYNZZt26dXZBd8WKFWrWrBnD9aJYjo7cA8C1OBY9xGIZjpxmj5yGyo7/DYB1lMfjsX79+nr55Ze1fft2bdu2TT179tTAgQO1d+9eSdJTTz2lb7/9Vl988YXWrl2rkydP6rbbbjOfn5WVpX79+unSpUvasGGD5s2bp7lz5+r555/31CZ5nMeymre3atx8s/rUrq2Zs2eT1URWgzWUx/8NQEXEsQiJnHY5chrA/wfAKjxxLNLJzRH+/tJ33+Xc/P09XZtiPfPMM3rllVf02Wef6cCBA/q///s/xcXF6YknnpAkhYWFKSAgQMuWLdPp06eVlJQkKWeEjw8//FC//PKLNm/erHvvvVcBAQElWvfMmTOVlZWl6667Tl999ZUOHjyoX375Ra+//roZbnr16qVWrVrp3nvv1Y4dO7RlyxYNHTpU3bp107XXXitJ6tmzp7Zt26YPPvhABw8e1AsvvKA9e/aUeF80bNhQq1atUnx8vP78809J0okTJ9S8eXNt2bKlyOfGxcUpLi5OFy5c0JkzZxQXF6d9+/aZ85944gktW7ZMr776qvbv36/x48dr27ZteuyxxyTl/LLiySef1IsvvqhFixZp9+7dGjp0qOrWratbb71VUk7ovemmm/Twww9ry5Yt+umnn/TYY4/p7rvvVt26dSVJQ4YMka+vrx588EHt3btXn332mWbMmKHRo0eXeH+g8vD+X2eOgn4FBMD9ckfEqFKliodr4rgKMTqIBTMcOe0v5DRUVuQ0wHpyj0dvC3SKd9SAAQN08803q0mTJmratKkmT56s4OBgbdq0SUlJSXrvvff02muvqWfPnmrXrp3mzJmjDRs2aNOmTZKk77//Xvv27dNHH32ktm3bqm/fvpo0aZJmzpzp8KgWFZFHstr/MuvMTZuUlZ1NVhNZDZ6V+7mdkS0BayiP59TgGuS0v5DTUJmR1QBr8cg5NQNGUlKSIclISkrydFVKZc6cOUZoaKg5nZWVZYwfP96oV6+e4ePjY7Rp08ZYunSp3XPeeecdIzIy0vDy8jK6detmGIZh7Nixw7j22msNf39/o0mTJsYXX3xhREVFGf/+97/N50kyFi5cWGR9Tp48aYwcOdKIiooyfH19jXr16hm33HKLsXr1arPM0aNHjVtuucUICgoyqlatatxxxx1GfHy83XKef/55Izw83AgNDTWeeuop47HHHjPrahiG0a1bN+OJJ56we87AgQON2NhYc3rRokVG48aNjSpVqhhRUVGGYRjG4cOHDUl29SmIpHy33GXk+vzzz42mTZsavr6+RosWLYzvvvvObn52drbx3HPPGeHh4Yafn59xww03GAcOHLAr88cffxj33HOPERwcbISEhBgPPPCAcf78ebsyO3fuNDp37mz4+fkZ9erVM15++eUi6w4YhmEcOnTIOHbsmJGdne3pqqCC+/XXnBsK99///tc4cOBAocejFbPIokWLjO+++8749ddfjQMHDhjPPvus4ePjY+zZs8cwDMMYPny4ERkZaaxatcrYtm2b0bFjR+P66683n5+ZmWm0bNnS6NWrl/Hzzz8bS5YsMWrVqmWMHTu2RPWw4r4pCXLaX8hpwF8qSk7LzQCXZ4HLHy/sBlhBdna2cezYMePQoUOFlrF6HsnMzDQ++eQTw9fX19i7d6+xatUqQ5Lx559/2pVr0KCB8dprrxmGYRjPPfec0aZNG7v5v//+uyHJ2LFjR6HrSktLM5KSkszb8ePHLb1vikNW+wtZDciRnZ1tHDhwwPjvf//r6apUGgXlwqLyYmHZExVTeTynZhXlfd+Q0/5CTgP+QlZzv+KyFlms8vLUOTWbYTCWY3JyskJDQ5WUlKSQkBBPVwcAnCI5OVknTpxQcHCwQkND5ePjI5vN5ulqoQI6ciTnb8OGnqyFNRmGoZSUFJ05c0Z16tRRtWrVCixXXrJIjRo1NG3aNN1+++2qXbu25s+fr9tvv12StH//fl111VXauHGjOnbsqKVLl6p///46efKkwsPDJUlvvfWWxowZozNnzpiXEChOedk3AFASFSWn5WaAXLlZ4PLHC0N2gCcZhqGMjAwlJSXpwoULqlevXqFZw6p5ZPfu3YqJiVFaWpqCg4M1f/583XzzzZo/f74eeOABpaen25W/7rrr1KNHD73yyit65JFHdPToUS1fvtycn5qaqqCgIC1ZskR9+/YtcJ3jx4/XhAkT8j1utX0DAGWRmJioU6dOqXbt2goKCiqXOa08OXIkfy68/FxT3umi5qHiqGjn1DyBfQOgoiKruVdxWYssVvl4+pwa4/s6IiVFCgvLuZ+QIAUFebY+AOCA3H8UZ8+e1YkTJzxcG1RkCQk5f+k2XzCbzaZq1aopNDTU01UptaysLH3xxRdKSUlRTEyMtm/froyMDPXq1css07x5czVo0MDs5LZx40a1atXK7OAmSX369NGIESO0d+9eXX311QWuKz093e4L2eTk5NJXnAwHwKIqSk7LzQC5crPA5Y8XhuwAK/Dz8yvyZJyVNWvWTHFxcUpKStKXX36p2NhYrV271qXrHDt2rN0lhJKTkxUZGenSdVZ4ZFbAckJDQ3Xx4kWdPXtWZ86c8XR1KryEhPy58PJzTXmni5qHiqUinFNDOUdOAyyJrOZexWUtsljl5alzanRyc1RqqqdrAAAlFhISopCQEGVkZCgrK8vT1UEFNXVqzt9ZszxbD6vy8fFx77Xonejy0UEWLlyo6OhoxcXFydfXN9+vaMPDwxUfHy9Jio+Pt+vgljs/d15hpkyZUuDoIKVGhgNgURUhp+VmgFy5WeDyxwtDdoCneXt7y8fHx9PVKDVfX181btxYktSuXTtt3bpVM2bM0F133aVLly4pMTHRLq+dPn1aERERkqSIiAht2bLFbnmnT5825xXGz89Pfn5+Tt4SkFkBa7HZbKpTp47CwsKUkZHh6epUeFOn5s+Fl59ryjtd1DxULOX5nBoqEHIaYDlkNfcqLmsVN3/EiKLno3zy5Dk1OrkBQCXg4+NTrr+8gbWdPZvz19/fs/WA8zE6CAC4XnnOabkZIFduFrj88cKQHQDnys7OVnp6utq1aycfHx+tWrVKgwcPliQdOHBAx44dU0xMjCQpJiZGkydPVkJCgsL+NzrFihUrFBISoujoaI9tAwBYibe3Nx1s3ODs2fy58PJzTXmni5oHAAAqD7KaexSXtco6HygpOrkBAACgQIwOAgAAYE1jx45V37591aBBA50/f17z58/XmjVrtHz5coWGhurBBx/U6NGjVaNGDYWEhGjUqFGKiYlRx44dJUm9e/dWdHS07r//fk2dOlXx8fEaN26cRo4cSRYDAAAAAABFGjDA0zVAZeXl6QoAAACgfChodJBcBY0Osnv3biUkJJhlGB0EAADAORISEjR06FA1a9ZMN9xwg7Zu3arly5frxhtvlCT9+9//Vv/+/TV48GB17dpVERERWrBggfl8b29vLV68WN7e3oqJidF9992noUOHauLEiZ7aJAAAAAAAUEEMGEBHOLgGI7kBAAAgH0YHAQAAsK733nuvyPn+/v6aOXOmZs6cWWiZqKgoLVmyxNlVAwAAAAAAAFyCTm4AAADIJ3d0kFOnTik0NFStW7fONzqIl5eXBg8erPT0dPXp00dvvvmm+fzc0UFGjBihmJgYBQUFKTY2ltFBAAAAAABAmTEyCAAAAFD50MnNEV5eUrduf90HAACo4CrE6CBkOAAAAFgdmRUAAMCayGkAAFgOndwcERAgrVnj6VoAAACgJMhwAAAAsDoyKwAAgDWR0wAAsBw6uQEAAAAAAAAAAAAAAAAoFJeMh6cxtioAAAAAACjWgAGcyAIAAAAAAAAAeAad3ByRkiLVrp1zS0nxdG0AAADgCDIcAAAArI7MCgAAYE3kNAAALMejndxmzZql1q1bKyQkRCEhIYqJidHSpUvN+WlpaRo5cqRq1qyp4OBgDR48WKdPn7ZbxrFjx9SvXz8FBgYqLCxMzzzzjDIzM51f2bNnc24AAAAoP8hwAAAAsDoyK4BKjhGDAVgWOQ0AAEvxaCe3+vXr6+WXX9b27du1bds29ezZUwMHDtTevXslSU899ZS+/fZbffHFF1q7dq1Onjyp2267zXx+VlaW+vXrp0uXLmnDhg2aN2+e5s6dq+eff95TmwQAAAAAAAAAAAAAAAAAcKIqnlz5gMt+mjN58mTNmjVLmzZtUv369fXee+9p/vz56tmzpyRpzpw5uuqqq7Rp0yZ17NhR33//vfbt26eVK1cqPDxcbdu21aRJkzRmzBiNHz9evr6+ntgsAAAAAAAAAAAAAAAAoNxhlF1YlUdHcssrKytLn376qVJSUhQTE6Pt27crIyNDvXr1Mss0b95cDRo00MaNGyVJGzduVKtWrRQeHm6W6dOnj5KTk83R4AqSnp6u5ORkuxsAAAAAAAAAAAA8g8uWAgAAVEzkPDiLxzu57d69W8HBwfLz89Pw4cO1cOFCRUdHKz4+Xr6+vqpWrZpd+fDwcMXHx0uS4uPj7Tq45c7PnVeYKVOmKDQ01LxFRkY6d6MAAKjAigqihFQAAAAAAAAAAAAAgLN59HKlktSsWTPFxcUpKSlJX375pWJjY7V27VqXrnPs2LEaPXq0OZ2cnExHNwAAAAAAyoCO7gAAAAAAAAAAV/F4JzdfX181btxYktSuXTtt3bpVM2bM0F133aVLly4pMTHRbjS306dPKyIiQpIUERGhLVu22C3v9OnT5rzC+Pn5yc/Pz/FKenlJ1177130AAOCQAQOkb7/1dC1QaZHhAAAAYHVkVgAAAGsipwEAYDmW+4+cnZ2t9PR0tWvXTj4+Plq1apU578CBAzp27JhiYmIkSTExMdq9e7cSEhLMMitWrFBISIiio6OdV6mAAGnr1pxbQIDzlgsAAADXIcMBAADA6sisAAAA1kROAwDAcjw6ktvYsWPVt29fNWjQQOfPn9f8+fO1Zs0aLV++XKGhoXrwwQc1evRo1ahRQyEhIRo1apRiYmLUsWNHSVLv3r0VHR2t+++/X1OnTlV8fLzGjRunkSNHlmykNgAAAAAAAAAAAAAAAACAJXm0k1tCQoKGDh2qU6dOKTQ0VK1bt9by5ct14403SpL+/e9/y8vLS4MHD1Z6err69OmjN99803y+t7e3Fi9erBEjRigmJkZBQUGKjY3VxIkTPbVJAAAAAAAAAAAAKKMBAzxdAwAAAEjkMliHRy9X+t577+nIkSNKT09XQkKCVq5caXZwkyR/f3/NnDlT586dU0pKihYsWKCIiAi7ZURFRWnJkiVKTU3VmTNn9K9//UtVqji5715qqtSwYc4tNdW5ywYAAIBrkOEAAABgdWRWAAAqlFmzZql169YKCQlRSEiIYmJitHTpUnN+WlqaRo4cqZo1ayo4OFiDBw/W6dOn7ZZx7Ngx9evXT4GBgQoLC9MzzzyjzMxMd28KyGkAAFiOR0dyKzcMQzp69K/7AAAAsD4yHAAAAKyOzAoAQIVSv359vfzyy2rSpIkMw9C8efM0cOBA/fzzz2rRooWeeuopfffdd/riiy8UGhqqxx57TLfddpt++uknSVJWVpb69euniIgIbdiwQadOndLQoUPl4+Ojl156ycNbV8mQ0wAAsBw6uQEAAAAAAAAAAABAGQ247HpukydP1qxZs7Rp0ybVr19f7733nubPn6+ePXtKkubMmaOrrrpKmzZtUseOHfX9999r3759WrlypcLDw9W2bVtNmjRJY8aM0fjx4+Xr6+uJzQIAALAEj16uFAAAVHwDBuTcAAAAAAAAAKCyyMrK0qeffqqUlBTFxMRo+/btysjIUK9evcwyzZs3V4MGDbRx40ZJ0saNG9WqVSuFh4ebZfr06aPk5GTt3bu30HWlp6crOTnZ7gYAAFDR0MkNAAAAAAAAAAAAAJxg9+7dCg4Olp+fn4YPH66FCxcqOjpa8fHx8vX1VbVq1ezKh4eHKz4+XpIUHx9v18Etd37uvMJMmTJFoaGh5i0yMtK5GwUAAGABdHIDAAAAAAAAAAAAACdo1qyZ4uLitHnzZo0YMUKxsbHat2+fS9c5duxYJSUlmbfjx4+7dH0AAACeUMXTFQAAAAAAAJVb7qXNv/3Ws/UAAAAAgLLy9fVV48aNJUnt2rXT1q1bNWPGDN111126dOmSEhMT7UZzO336tCIiIiRJERER2rJli93yTp8+bc4rjJ+fn/z8/Jy8JQAAANbCSG6OsNmk6Oicm83m6doAAADAEWQ4AAAAWB2ZFQCACi87O1vp6elq166dfHx8tGrVKnPegQMHdOzYMcXExEiSYmJitHv3biUkJJhlVqxYoZCQEEVHR7u97pUaOQ0AAMthJDdHBAZKe/d6uhYAAAAoCTIcAJQJo6sBgBuQWQFUcGRKVDZjx45V37591aBBA50/f17z58/XmjVrtHz5coWGhurBBx/U6NGjVaNGDYWEhGjUqFGKiYlRx44dJUm9e/dWdHS07r//fk2dOlXx8fEaN26cRo4cyUht7kZOAwDAcujkBgAAAAAAAAAAAABllJCQoKFDh+rUqVMKDQ1V69attXz5ct14442SpH//+9/y8vLS4MGDlZ6erj59+ujNN980n+/t7a3FixdrxIgRiomJUVBQkGJjYzVx4kRPbRIAAIBl0MkNAAA4Xe6vdAEAQMXD/3kAAAAAKNh7771X5Hx/f3/NnDlTM2fOLLRMVFSUlixZ4uyqAQDgMozeC3fx8nQFyoXUVKlFi5xbaqqnawMAAABHkOEAwPIGDKDTHIBKjswKAABgTeQ0AAAsh5HcHGEY0r59f90HAACA9ZHhAKDc4tefACoNMiuASoJ8B6DcIacBAGA5jOQGAAAAAAAAAAAAAAAAALAsOrkBAAAAAAAAAAAAAAAAACyLy5UCAIBC5V5KIheXlAAAAAAAAAAAAAAAuBsjuQEAAAAAAAAAAMDlBgzI/6NKAAAAAHAEndwAAAAAAAAAAADgNq7u7EZHOgAAAKDi4XKljrDZpKiov+4DAADA+shwAAAAsDoyKwAAgDWR0wAAsBw6uTkiMFA6csTTtQAAAEBJkOEAAABgdWRWAAAAayKnAQBgOVyuFAAAAAAAAAAAAAAAAABgWYzkBgAASmXAAE/XAAAAAAAAAAAAAABQGTCSmyMuXpTat8+5Xbzo6doAAADAEWQ4AAAAWB2ZFQAcxg8uAbgVOQ0AXGbAALIdSoeR3ByRnS1t2/bXfQAAAFgfGQ4AAABWR2YFAACwJnIaAACWQyc3AAAAAAAAAAAAAAAAAKXG6GxwNS5XCgAAAAAAAAAAAAAAAACwLEZyAwAAAAAAAAAAAAAAAOAyjPSGsqKTGwAAAAAAAAAAAAAAAFCJ0QkNVkcnNwAA4BQEXwAAUFbkCQAAgIqBXAcAAADA2bw8XYFyo1atnBsAAADKDzIcAFgWX3wCpTdlyhS1b99eVatWVVhYmG699VYdOHDArkz37t1ls9nsbsOHD7crc+zYMfXr10+BgYEKCwvTM888o8zMTHduCiQyKwAAgFWR0wAAsBRGcnNEUJB05oynawEAQIUyYID07beergUqNDIcAACooNauXauRI0eqffv2yszM1LPPPqvevXtr3759CgoKMss9/PDDmjhxojkdGBho3s/KylK/fv0UERGhDRs26NSpUxo6dKh8fHz00ksvuXV7KjUyKwAAgDWR0wAAsBxGcgMAAEA+jA4CAABgXcuWLdOwYcPUokULtWnTRnPnztWxY8e0fft2u3KBgYGKiIgwbyEhIea877//Xvv27dNHH32ktm3bqm/fvpo0aZJmzpypS5cuuXuTAAAAAAAAgCLRyQ0AAAD55I4OsmnTJq1YsUIZGRnq3bu3UlJS7Mo9/PDDOnXqlHmbOnWqOS93dJBLly5pw4YNmjdvnubOnavnn3/e3ZsDAABQoSUlJUmSatSoYff4xx9/rFq1aqlly5YaO3asUlNTzXkbN25Uq1atFB4ebj7Wp08fJScna+/eve6pOAAAAAAAAOAgLlfqiIsXpb59c+4vXSoFBHi2PgAAuBCXEYWUMzpIXnPnzlVYWJi2b9+url27mo/njg5SkNzRQVauXKnw8HC1bdtWkyZN0pgxYzR+/Hj5+vq6dBvIcAAAoDLIzs7Wk08+qU6dOqlly5bm40OGDFFUVJTq1q2rXbt2acyYMTpw4IAWLFggSYqPj7fr4CbJnI6Pjy9wXenp6UpPTzenk5OTnb05lQ+ZFQAAwJrIaQAqgQEDcv7yvSDKCzq5OSI7W1q79q/7AAAAlUxRo4N89NFHioiI0IABA/Tcc88pMDBQUuGjg4wYMUJ79+7V1Vdf7dpKk+EAAEAlMHLkSO3Zs0fr16+3e/yRRx4x77dq1Up16tTRDTfcoEOHDunKK68s1bqmTJmiCRMmlKm+uAyZFQAAwJrIaQAqkdzOboDV0ckNAAAARWJ0EAAAAGt67LHHtHjxYq1bt07169cvsmyHDh0kSb/99puuvPJKRUREaMuWLXZlTp8+LUmFjtQ7duxYjR492pxOTk5WZGRkWTYBAAAAAAAAcAid3AAAAFAkRgcBAACwFsMwNGrUKC1cuFBr1qxRo0aNin1OXFycJKlOnTqSpJiYGE2ePFkJCQkKCwuTJK1YsUIhISGKjo4ucBl+fn7y8/NzzkYAAAAAAAAAJeDl6QoAAADAunJHB1m9enWJRgeRckYAyR0NJJcjo4MkJSWZt+PHj5d1EwAAACqckSNH6qOPPtL8+fNVtWpVxcfHKz4+XhcvXpQkHTp0SJMmTdL27dt15MgRLVq0SEOHDlXXrl3VunVrSVLv3r0VHR2t+++/Xzt37tTy5cs1btw4jRw5ko5sAAAAAAAAsBxGcgMAAEA+jA4CAJXXgAFFTwPwvFmzZkmSunfvbvf4nDlzNGzYMPn6+mrlypWaPn26UlJSFBkZqcGDB2vcuHFmWW9vby1evFgjRoxQTEyMgoKCFBsbq4kTJ7pzUwAAAAAAgJtxvg/lFZ3cAAAAkM/IkSM1f/58ffPNN+boIJIUGhqqgIAAHTp0SPPnz9fNN9+smjVrateuXXrqqacKHR1k6tSpio+PZ3QQAAAAJzAMo8j5kZGRWrt2bbHLiYqK0pIlS5xVLQAAPI4vbAEAAICKi05ujgoM9HQNAABwm8JOCHKisPKoMKODkOEAAABgdWRWAAAAayKnAQBgKXRyc0RQkJSS4ulaAAAAuE2FGB2EDAcAAACrI7MCAABYEzkNAADLoZMbAAAAAAAAAAAAyi2uPgAAAABUfF6ergAAAAAAAAAAAAAAAAAAAIXxaCe3KVOmqH379qpatarCwsJ066236sCBA3ZlunfvLpvNZncbPny4XZljx46pX79+CgwMVFhYmJ555hllZmY6r6JpaVK/fjm3tDTnLRcAgEpkwAB+VQs3I8MBAADA6sisAAAA1kROAwDAcjx6udK1a9dq5MiRat++vTIzM/Xss8+qd+/e2rdvn4KCgsxyDz/8sCZOnGhOBwYGmvezsrLUr18/RUREaMOGDTp16pSGDh0qHx8fvfTSS86paFaWtGTJX/cBAABgfWQ4AAAAWB2ZFQAAwJrIaQAAWI5HO7ktW7bMbnru3LkKCwvT9u3b1bVrV/PxwMBARUREFLiM77//Xvv27dPKlSsVHh6utm3batKkSRozZozGjx8vX19fl24DAAAAAAAAAAAAAAAAAMB1PHq50sslJSVJkmrUqGH3+Mcff6xatWqpZcuWGjt2rFJTU815GzduVKtWrRQeHm4+1qdPHyUnJ2vv3r0Fric9PV3Jycl2NwAAAAAAYC1c7hwAAAAAAAAAIHl4JLe8srOz9eSTT6pTp05q2bKl+fiQIUMUFRWlunXrateuXRozZowOHDigBQsWSJLi4+PtOrhJMqfj4+MLXNeUKVM0YcIEF20JAAAAAAAAAAAAAAAAAMBZLNPJbeTIkdqzZ4/Wr19v9/gjjzxi3m/VqpXq1KmjG264QYcOHdKVV15ZqnWNHTtWo0ePNqeTk5MVGRlZuooDAIBSyx2Z5dtvPVsPAAAAAAAAAAAAAIB1WeJypY899pgWL16s1atXq379+kWW7dChgyTpt99+kyRFRETo9OnTdmVypyMiIgpchp+fn0JCQuxuAAAAAADAmrhsKQAAAAAAAABUbh7t5GYYhh577DEtXLhQP/zwgxo1alTsc+Li4iRJderUkSTFxMRo9+7dSkhIMMusWLFCISEhio6Odkm9AQAAAAAAAAAAAAAAAADu4dFObiNHjtRHH32k+fPnq2rVqoqPj1d8fLwuXrwoSTp06JAmTZqk7du368iRI1q0aJGGDh2qrl27qnXr1pKk3r17Kzo6Wvfff7927typ5cuXa9y4cRo5cqT8/PycU9GgIMkwcm5BQc5ZJgAAAFyLDAcAAACrI7MCAFChTJkyRe3bt1fVqlUVFhamW2+9VQcOHLAr0717d9lsNrvb8OHD7cocO3ZM/fr1U2BgoMLCwvTMM88oMzPTnZsCchqACoirJaC8q+LJlc+aNUtSTpjLa86cORo2bJh8fX21cuVKTZ8+XSkpKYqMjNTgwYM1btw4s6y3t7cWL16sESNGKCYmRkFBQYqNjdXEiRPduSkAAAAAAAAAAAAAKrG1a9dq5MiRat++vTIzM/Xss8+qd+/e2rdvn4LydJR6+OGH7b7LDAwMNO9nZWWpX79+ioiI0IYNG3Tq1CkNHTpUPj4+eumll9y6PQAAAFbi0U5uhmEUOT8yMlJr164tdjlRUVFasmSJs6oFAAAAAAAAAAAAACWybNkyu+m5c+cqLCxM27dvV9euXc3HAwMDFRERUeAyvv/+e+3bt08rV65UeHi42rZtq0mTJmnMmDEaP368fH19XboNAAAAVuXRy5WWG2lp0h135NzS0jxdGwAAADiCDAcADuEyBQDgQWRWAAAqtKSkJElSjRo17B7/+OOPVatWLbVs2VJjx45VamqqOW/jxo1q1aqVwsPDzcf69Omj5ORk7d271z0VBzkNAAAL8uhIbuVGVpb05Zc59+fO9WhVAAAA4CAyHAAAAKyOzAoAQIWVnZ2tJ598Up06dVLLli3Nx4cMGaKoqCjVrVtXu3bt0pgxY3TgwAEtWLBAkhQfH2/XwU2SOR0fH1/gutLT05Wenm5OJycnO3tzKh9yGgAAlkMnNwAAAAAAAAAAAABwopEjR2rPnj1av3693eOPPPKIeb9Vq1aqU6eObrjhBh06dEhXXnllqdY1ZcoUTZgwoUz1BQAAsDouVwoAAAAAAAAAAIAKacCAnBvgTo899pgWL16s1atXq379+kWW7dChgyTpt99+kyRFRETo9OnTdmVypyMiIgpcxtixY5WUlGTejh8/XtZNAAAAsBxGcgMAAAAAAAAAAECFQsc2eIJhGBo1apQWLlyoNWvWqFGjRsU+Jy4uTpJUp04dSVJMTIwmT56shIQEhYWFSZJWrFihkJAQRUdHF7gMPz8/+fn5OWcjAAAALIpObgAAwK04wQgAAAAAAACgIho5cqTmz5+vb775RlWrVlV8fLwkKTQ0VAEBATp06JDmz5+vm2++WTVr1tSuXbv01FNPqWvXrmrdurUkqXfv3oqOjtb999+vqVOnKj4+XuPGjdPIkSPpyAYAACo1OrkBAAAAAAA6ogMAAABAGc2aNUuS1L17d7vH58yZo2HDhsnX11crV67U9OnTlZKSosjISA0ePFjjxo0zy3p7e2vx4sUaMWKEYmJiFBQUpNjYWE2cONGdmwIAAGA5dHIDAAAAAAAAAAAAgDIyDKPI+ZGRkVq7dm2xy4mKitKSJUucVS0AQCXHj1tRUdDJzRGBgdKFC3/dBwAAgPWR4QAAAGB1ZFYAAABrIqcBgMvldr779lvP1gPlB53cHGGzSUFBnq4FAAAASoIMBwAAAKsjswIAAFgTOQ0AAMvx8nQFAAAAAAAAAAAAAAAAAFQ+AwZwSVU4hk5ujkhPl4YNy7mlp3u6NgAAAHAEGQ4AAABWR2YFAACwJnIaAACWQyc3R2RmSvPm5dwyMz1dGwAAADiCDAcAAACrI7MCAABYEzkNAADLoZMbAAAAAAAoF7h0AQAAgPWR1wAAAAC4Ap3cAAAAAAAAAAAAAAAAAACWRSc3AADgcYzKAgAAAAAAAAAAAAAoDJ3cAAAAAAAAAAAAAAAAAACWRSc3AABgOYzqBgAAAAAAUL4wUj8AAAAAV6ri6QoAAABr4CQkAAAAAAAAAAAAAMCK6OTmiMBAKSHhr/sAAACwPjIcAAAArI7MCgAAYE3kNAAALIdObo6w2aTatT1dCwAAXIIR3FBhkeEAAABgdWRWAAAAayKnAQBgOV6ergAAAAAAAAAAAAAAAAAAAIWhk5sj0tOlkSNzbunpnq4NAAAAHEGGAwAAgNWRWQEAAKyJnAYAgOXQyc0RmZnSm/+fvTuPq7LM/z/+ZhdRIFS2cm1xS9O0lFYXEqxIk6YsplFz8vt10G/lTDXOmOYyOdM06dSYLVPYIllOWWllKm6laEZD5ZKlYVoKlAaICyJcvz/u3zl6ZIcD5wZez8fjfnTOfd/nPp/74gRv7/s61/WMtZw+7elqAAAAUB1kOAAAANgdmRUAAMCeyGkAANgOndwAAAAAAAAAAAAAAAAAALZFJzcAAAAAAAAAAAAAAAAAgG35eroAAAAAAADQ8BISPF0BAAAAAAAAAADVw0huAAAAAAAAAAAAAAAAAADbopMbAAAAAAAAAAAAAAAAAMC26OQGAAAAAAAAAAAAAAAAALAtX08X0CgEBkpZWWceAwAAwP7IcAAAALA7MisAAIA9kdMAALAdRnKrDm9vqVMna/GmyQAAABoFMhwAAGii5s6dqyuuuEKtW7dWeHi4Ro4cqd27d7vsc/LkSSUnJ6tNmzZq1aqVEhMTlZOT47LP/v37ddNNN6lly5YKDw/Xgw8+qNOnTzfkqYDMCgAAYE/kNAAAbIe/yAAAACiDG6cAAAD2tWHDBiUnJ2vLli1avXq1iouLNWzYMB07dsy5zwMPPKDly5dr6dKl2rBhgw4ePKhRo0Y5t5eUlOimm27SqVOntHnzZr388statGiRpk+f7olTAgAAAAAAACpFJ7fqOHVKevBBazl1ytPVAAAA1LsmceOUDAcAAJqolStXauzYserZs6cuu+wyLVq0SPv371dGRoYkKT8/Xy+++KKefPJJDRkyRP369VNKSoo2b96sLVu2SJJWrVqlnTt36rXXXlOfPn00fPhwzZ49WwsWLNApslPDIbMCQINJSLAWAKgWchoAALZDJ7fqKC6WnnjCWoqLPV0NAABAvWsSN07JcAAAoJnIz8+XJIWFhUmSMjIyVFxcrNjYWOc+3bp1U4cOHZSeni5JSk9PV69evRQREeHcJy4uTgUFBdqxY0e571NUVKSCggKXBXVEZgUAALAnchoAALZDJzcAAABUqaFunAIAAKBmSktLdf/99+vqq6/WpZdeKknKzs6Wv7+/QkNDXfaNiIhQdna2c5+zc5pju2NbeebOnauQkBDn0r59ezefDQAAAAAAAFA+OrkBAACgUg1545TRQQAAAGomOTlZ27dv15IlS+r9vaZOnar8/HzncuDAgXp/TwAAAAAAAECikxsAAACq0JA3ThkdBAAAoPomTZqkFStWaN26dbrggguc6yMjI3Xq1Cnl5eW57J+Tk6PIyEjnPjk5OWW2O7aVJyAgQMHBwS4LAAAAAAAA0BDo5AYAAIAKNfSNU0YHAQAAqJoxRpMmTdKyZcu0du1ade7c2WV7v3795Ofnp7S0NOe63bt3a//+/YqJiZEkxcTE6KuvvlJubq5zn9WrVys4OFg9evRomBMBAAAAAAAAqolObgAAACjDUzdOGR0EAACgasnJyXrttdeUmpqq1q1bKzs7W9nZ2Tpx4oQkKSQkROPHj9eUKVO0bt06ZWRkaNy4cYqJidHAgQMlScOGDVOPHj10991364svvtBHH32kadOmKTk5WQEBAZ48PQAAAAAAAKAMX08XAAAAPCMhwdMVwM6Sk5OVmpqqd99913njVLJumAYGBrrcOA0LC1NwcLAmT55c4Y3Txx9/XNnZ2dw4BQAAcIOFCxdKkgYNGuSyPiUlRWPHjpUkzZs3T97e3kpMTFRRUZHi4uL0zDPPOPf18fHRihUrNHHiRMXExCgoKEhjxozRrFmzGuo0AAAAAAAAgGqjk1t1BAZK27efeQwAANDENYkbp2Q4ACgXHd2Bxs8YU+U+LVq00IIFC7RgwYIK9+nYsaM++OADd5aGmiKzAgAA2BM5DQAA2/HodKVz587VFVdcodatWys8PFwjR47U7t27XfY5efKkkpOT1aZNG7Vq1UqJiYnKyclx2Wf//v266aab1LJlS4WHh+vBBx/U6dOn3Veot7fUs6e1eDPDKwAAaPqMMeUujg5u0pkbp0eOHNGxY8f09ttvKzIy0uU4jhunx48f108//aQnnnhCvr4N9D0LMhwAAADsjswKoAlISOCLFACaIHIaADQ4ciWq4tG/yBs2bFBycrK2bNmi1atXq7i4WMOGDdOxY8ec+zzwwANavny5li5dqg0bNujgwYMaNWqUc3tJSYluuukmnTp1Sps3b9bLL7+sRYsWafr06Z44JQAAAAAAAAAAAAAAAACAG3l0utKVK1e6PF+0aJHCw8OVkZGh6667Tvn5+XrxxReVmpqqIUOGSLKmyOrevbu2bNmigQMHatWqVdq5c6fWrFmjiIgI9enTR7Nnz9bDDz+sRx99VP7+/nUv9NQp6bHHrMd/+pPkjmMCAACgfpHhAAAAYHdkVgAAAHsipwEAYDu2Gls1Pz9fkhQWFiZJysjIUHFxsWJjY537dOvWTR06dFB6erokKT09Xb169VJERIRzn7i4OBUUFGjHjh3uKay4WJo501qKi91zTAAAANQvMhwAAADsjswKAABgT+Q0AI0Q032iqfPoSG5nKy0t1f3336+rr75al156qSQpOztb/v7+Cg0Nddk3IiJC2dnZzn3O7uDm2O7YVp6ioiIVFRU5nxcUFLjrNAAAaBQIuAAAAAAAAAAAAACAxsI2I7klJydr+/btWrJkSb2/19y5cxUSEuJc2rdvX+/vCQAAAAAAAAAAAAAAAACoOVt0cps0aZJWrFihdevW6YILLnCuj4yM1KlTp5SXl+eyf05OjiIjI5375OTklNnu2FaeqVOnKj8/37kcOHDAjWcDAAAAAAAAAAAAAAAAAHAXj3ZyM8Zo0qRJWrZsmdauXavOnTu7bO/Xr5/8/PyUlpbmXLd7927t379fMTExkqSYmBh99dVXys3Nde6zevVqBQcHq0ePHuW+b0BAgIKDg10WAAAAAAAAAAAAAKituXPn6oorrlDr1q0VHh6ukSNHavfu3S77nDx5UsnJyWrTpo1atWqlxMTEMgN67N+/XzfddJNatmyp8PBwPfjggzp9+nRDngoAAIDteLSTW3Jysl577TWlpqaqdevWys7OVnZ2tk6cOCFJCgkJ0fjx4zVlyhStW7dOGRkZGjdunGJiYjRw4EBJ0rBhw9SjRw/dfffd+uKLL/TRRx9p2rRpSk5OVkBAgCdPDwAAAAAAAAAAAEAzsWHDBiUnJ2vLli1avXq1iouLNWzYMB07dsy5zwMPPKDly5dr6dKl2rBhgw4ePKhRo0Y5t5eUlOimm27SqVOntHnzZr388statGiRpk+f7olTAgAAsA1fT775woULJUmDBg1yWZ+SkqKxY8dKkubNmydvb28lJiaqqKhIcXFxeuaZZ5z7+vj4aMWKFZo4caJiYmIUFBSkMWPGaNasWQ11GgAAwE0SEjxdAQAAAAAAAADUzsqVK12eL1q0SOHh4crIyNB1112n/Px8vfjii0pNTdWQIUMkWfdFu3fvri1btmjgwIFatWqVdu7cqTVr1igiIkJ9+vTR7Nmz9fDDD+vRRx+Vv7+/J04NAADA4zzayc0YU+U+LVq00IIFC7RgwYIK9+nYsaM++OADd5Z2bhHSp5+eeQwAAAD7I8MBAADA7sisAAA0afn5+ZKksLAwSVJGRoaKi4sVGxvr3Kdbt27q0KGD0tPTNXDgQKWnp6tXr16KiIhw7hMXF6eJEydqx44d6tu3b8OeRHNFTgMAj3EMirF8uWfrgP3UarrSLl266PDhw2XW5+XlqUuXLnUuynZ8fKQrrrAWHx9PVwMAAFChZpfTKkOGAwAANkNWQxlkVgAAbKE+clppaanuv/9+XX311br00kslSdnZ2fL391doaKjLvhEREcrOznbuc3YHN8d2x7byFBUVqaCgwGVBHZHTAACwnVp1ctu3b59KSkrKrC8qKtKPP/5Y56IAAABQO+Q0AAAA+yKrAQAA2FN95LTk5GRt375dS5YsqWt5VZo7d65CQkKcS/v27ev9PQEAABpajaYrfe+995yPP/roI4WEhDifl5SUKC0tTZ06dXJbcbZx6pT0z39aj++7T2KuewAAYDPNNqdVhgwHAABsgqyGCpFZAQDwqPrKaZMmTdKKFSu0ceNGXXDBBc71kZGROnXqlPLy8lxGc8vJyVFkZKRzn08d02Setd2xrTxTp07VlClTnM8LCgro6FZX5DQAAGynRp3cRo4cKUny8vLSmDFjXLb5+fmpU6dO+sc//uG24myjuFh66CHr8e9+R4gBAAC202xzWmXIcAAAwCbIaqgQmRUAAI9yd04zxmjy5MlatmyZ1q9fr86dO7ts79evn/z8/JSWlqbExERJ0u7du7V//37FxMRIkmJiYvSXv/xFubm5Cg8PlyStXr1awcHB6tGjR7nvGxAQoICAgGrXiWogpwEAYDs16uRWWloqSercubO2bdumtm3b1ktRAAAAqBlyGgAAgH2R1QAAAOzJ3TktOTlZqampevfdd9W6dWtlZ2dLkkJCQhQYGKiQkBCNHz9eU6ZMUVhYmIKDgzV58mTFxMRo4MCBkqRhw4apR48euvvuu/X4448rOztb06ZNU3JyMh3ZAABAs1ajTm4OWVlZ7q4DAAAAbkBOAwA0JwkJ1n+XL/dsHUB1kdUAAADsyV05beHChZKkQYMGuaxPSUnR2LFjJUnz5s2Tt7e3EhMTVVRUpLi4OD3zzDPOfX18fLRixQpNnDhRMTExCgoK0pgxYzRr1iy31AgAANBY1aqTmySlpaUpLS1Nubm5zm85OLz00kt1LgwAAAC1Q04DAACwL7IaAAD2kJDAlyXgyh05zRhT5T4tWrTQggULtGDBggr36dixoz744INqvScAABVxfEEUaCpq1clt5syZmjVrlvr376+oqCh5eXm5uy4AAFAPCLNNHzkNAADAvshqAAAA9kROAwAAsL9adXJ79tlntWjRIt19993urgcAAAB1QE4DAACwL7IaAACAPZHTAAAA7M+7Ni86deqUrrrqKnfXAgAAUEZCAiPQ1QQ5DQAAwL7IagAAAPZETgMAALC/WnVy++1vf6vU1FR312JfLVpI69ZZS4sWnq4GAACgQs0up1WGDAcAAGyGrIYyyKwAANgCOQ1lkNMAALCdWk1XevLkST3//PNas2aNevfuLT8/P5ftTz75pFuKsw0fH2nQIE9XAQAAUKVml9MqQ4YDAAA2Q1ZDGWRWAABsgZyGMshpAADYTq06uX355Zfq06ePJGn79u0u27y8vOpcFAAAAGqHnAYAAGBfZDUAQFOSkODpCgD3IacBAADYX606ua1bt87dddhbcbH0/PPW4wkTpHO+vQEAAGAXzS6nVYYMBwAAbIashjLIrAAA2AI5DWWQ0wAAsJ1adXJrdk6dkiZNsh6PHUuIAQAAaAzIcAAAALA7MisAAIA9kdMAALCdWnVyGzx4cKVD865du7bWBQEAAKD2yGkAgIownRTgeWQ1AAAAeyKnAQAA2F+tOrk55qR3KC4uVmZmprZv364xY8a4oy4AAADUAjkNAADAvshqAAAA9kROAwA0Ro4vtS5f7tk6gIZSq05u8+bNK3f9o48+qsLCwjoVBAAAIDHaTG2R0wAAzREX9NBYkNUAAADsiZwGAABgf97uPNivf/1rvfTSS+48JAAAANyAnAYAAGBfZDUAABpOQgJfrkT1kdMAAI0ReQdNVa1GcqtIenq6WrRo4c5DAgAAwA3IaQAAAPZFVgMANBbcLEVzQ04DAACwj1p1chs1apTLc2OMDh06pM8++0yPPPKIWwoDAABAzZHTAADNATdX0ViR1QAAAOyJnAYAAGB/terkFhIS4vLc29tbXbt21axZszRs2DC3FGYrAQHSihVnHgMAANhUs8tplSHDAQAAmyGroQwyKwAAtkBOQxnkNAAAbKdWndxSUlLcXYe9+fpKN93k6SoAAACq1OxyWmXIcACaOcdoZ8uXe7YOAGeQ1VAGmRUAAFsgp6EMchoAALZTq05uDhkZGdq1a5ckqWfPnurbt69bigIAAEDdkNMAAADsi6wGAABgT+Q0AAAA+6pVJ7fc3FyNHj1a69evV2hoqCQpLy9PgwcP1pIlS9SuXTt31uh5xcXS4sXW46Qkyc/Ps/UAAABUoNnltMqQ4QBA0pkR3QB4HlkNZZBZAQCwBXIayiCnAQBgO961edHkyZN19OhR7dixQ0eOHNGRI0e0fft2FRQU6P/+7//cXaPnnToljRtnLadOeboaAACACjW7nFYZMhwAALAZshrKILMCAGAL5DSUQU4DAMB2ajWS28qVK7VmzRp1797dua5Hjx5asGCBhg0b5rbiAAAAUDPkNAAAAPsiqwEAANgTOQ0AAMD+atXJrbS0VH7lDMnq5+en0tLSOhcFAADci2nKmg9yGgAAgH2R1QAAAOyJnAYAAGB/tZqudMiQIbrvvvt08OBB57off/xRDzzwgIYOHeq24gAAAFAz5DQAAAD7IqsBAADYEzkNAADA/mrVye1f//qXCgoK1KlTJ1144YW68MIL1blzZxUUFOjpp592d40AAACoJnIaAACAfZHVAAAA7ImcBgCA/SQkMFsVXNVqutL27dvr888/15o1a/T1119Lkrp3767Y2Fi3FgcAAICaIacBAADYF1kNAADAnshpAAAA9lejkdzWrl2rHj16qKCgQF5eXrrhhhs0efJkTZ48WVdccYV69uypjz/+uL5qBQAAQAXIaQAAAPZFVgMAALAnchoAoClgxDM0FzXq5DZ//nzde++9Cg4OLrMtJCRE//M//6Mnn3zSbcXZRkCA9Oab1hIQ4OlqAAAAymi2Oa0yZDgAAGATZDVUiMwKwOa4YYqmjpyGCpHTAACwnRp1cvviiy8UHx9f4fZhw4YpIyOjzkXZjq+v9KtfWYtvrWZ4BQAAqFfNNqdVhgwHAABsgqyGCpFZAQDwKHIaKkROAwDAdmrUyS0nJ0d+fn4Vbvf19dVPP/1U56IAAABQM+Q0AAAA+yKrAQAA2BM5DQAAoPGoUSe3888/X9u3b69w+5dffqmoqKg6F2U7p09LS5day+nTnq4GAACgjGab0ypDhgPQTDGlFGA/7s5qGzduVEJCgqKjo+Xl5aV33nnHZfvYsWPl5eXlspw7QsmRI0eUlJSk4OBghYaGavz48SosLKzRecENyKwAAHgU19RQIXIaAAC2U6NObjfeeKMeeeQRnTx5ssy2EydOaMaMGbr55pvdVpxtFBVJt99uLUVFnq4GAACgjPrIaY3+5ikZDgAA2IS7s9qxY8d02WWXacGCBRXuEx8fr0OHDjmX119/3WV7UlKSduzYodWrV2vFihXauHGjJkyYUP2TgnuQWQE0EnyRAk1Vs733iaqR0wAAsJ0aTSA+bdo0vf3227rkkks0adIkde3aVZL09ddfa8GCBSopKdGf//zneikUAAAAFauPnOa4eXrPPfdo1KhR5e4THx+vlJQU5/OAgACX7UlJSTp06JBWr16t4uJijRs3ThMmTFBqamoNzxAAAKDxcndWGz58uIYPH17pPgEBAYqMjCx3265du7Ry5Upt27ZN/fv3lyQ9/fTTuvHGG/XEE08oOjq62rUAAAA0Ztz7BAAAaDxq1MktIiJCmzdv1sSJEzV16lQZYyRJXl5eiouL04IFCxQREVEvhQIAAKBi9ZHTuHkKAADgHp64prZ+/XqFh4frvPPO05AhQzRnzhy1adNGkpSenq7Q0FBnRpOk2NhYeXt7a+vWrbr11lvLPWZRUZGKzhrFoqCgwK01AwAANDTufQIAADQeNerkJkkdO3bUBx98oF9++UV79uyRMUYXX3yxzjvvvPqoDwAAANXkiZzm7pun3DgFAABNVUNmtfj4eI0aNUqdO3fW3r179ac//UnDhw9Xenq6fHx8lJ2drfDwcJfX+Pr6KiwsTNnZ2RUed+7cuZo5c6bb6wUAAPAk7n0CAAA0DjXu5OZw3nnn6YorrnBnLQAAwI0SEjxdATyloXJafdw85cYpAABo6hoiq40ePdr5uFevXurdu7cuvPBCrV+/XkOHDq31cadOnaopU6Y4nxcUFKh9+/Z1qhUAAMAuuPcJAABgb7Xu5AYAAIDmrT5unnLjFAAAwP26dOmitm3bas+ePRo6dKgiIyOVm5vrss/p06d15MiRCqeil6yp6gMCAuq7XAAAAAAAAKAMb08XAAAAgKbh7Junkmp18zQgIEDBwcEuCwAAAOrmhx9+0OHDhxUVFSVJiomJUV5enjIyMpz7rF27VqWlpRowYICnygQAAAAAACgjIYEZrGDxaCe3jRs3KiEhQdHR0fLy8tI777zjsn3s2LHy8vJyWeLj4132OXLkiJKSkhQcHKzQ0FCNHz9ehYWF7i3U319KSbEWf3/3HhsAAKCJsN3NUzIcAABoogoLC5WZmanMzExJUlZWljIzM7V//34VFhbqwQcf1JYtW7Rv3z6lpaVpxIgRuuiiixQXFydJ6t69u+Lj43Xvvffq008/1aZNmzRp0iSNHj1a0dHRHjyzZojMCgAAYE/kNAAAbMej05UeO3ZMl112me655x6NGjWq3H3i4+OVkpLifH7ulAhJSUk6dOiQVq9ereLiYo0bN04TJkxQamqq+wr185PGjnXf8QAAABqBwsJC56hs0pmbp2FhYQoLC9PMmTOVmJioyMhI7d27Vw899FCFN0+fffZZFRcXN+zNUzIcAABooj777DMNHjzY+dwx3fuYMWO0cOFCffnll3r55ZeVl5en6OhoDRs2TLNnz3a5rrZ48WJNmjRJQ4cOlbe3txITE/XUU081+Lk0e2RWAAAAeyKnAQBgOx7t5DZ8+HANHz680n0CAgIqnM5q165dWrlypbZt26b+/ftLkp5++mndeOONeuKJJ/jmKQAAQB1w8xQAAMCeBg0aJGNMhds/+uijKo8RFhbm3i+JAgAAAAAAAPXIo53cqmP9+vUKDw/XeeedpyFDhmjOnDlq06aNJCk9PV2hoaHODm6SFBsbK29vb23dulW33nqre4o4fVpyXByMi5N8bd9sAAAAddbob56S4QAAAGB3ZFYAAAB7IqcBAGA7tv5rHB8fr1GjRqlz587au3ev/vSnP2n48OFKT0+Xj4+PsrOzFR4e7vIaX19fhYWFKTs7u8LjFhUVqaioyPm8oKCg8kKKiqSbb7YeFxYSYgAAABoDMhwAAADsjswKAB6VkGD9d/lyz9YBwIbIaQAA2I63pwuozOjRo3XLLbeoV69eGjlypFasWKFt27Zp/fr1dTru3LlzFRIS4lzat2/vnoIBAECDSEg4cxESAAAAAAAAAOxi48aNSkhIUHR0tLy8vPTOO++4bB87dqy8vLxclvj4eJd9jhw5oqSkJAUHBys0NFTjx49XYWFhA54FAACA/di6k9u5unTporZt22rPnj2SpMjISOXm5rrsc/r0aR05ckSRkZEVHmfq1KnKz893LgcOHKjXugEAAAAAAAAAAAA0fceOHdNll12mBQsWVLhPfHy8Dh065Fxef/11l+1JSUnasWOHVq9erRUrVmjjxo2aMGFCfZcOAABga41qXNUffvhBhw8fVlRUlCQpJiZGeXl5ysjIUL9+/SRJa9euVWlpqQYMGFDhcQICAhQQENAgNQMAAAAAAAAAAABoHoYPH67hw4dXuk9AQECFA3bs2rVLK1eu1LZt29S/f39J0tNPP60bb7xRTzzxhKKjo91eMwAAQGPg0ZHcCgsLlZmZqczMTElSVlaWMjMztX//fhUWFurBBx/Uli1btG/fPqWlpWnEiBG66KKLFBcXJ0nq3r274uPjde+99+rTTz/Vpk2bNGnSJI0ePZqABwAAAAAAAAAAgGpLSLAWoL6tX79e4eHh6tq1qyZOnKjDhw87t6Wnpys0NNTZwU2SYmNj5e3tra1bt3qiXAAAAFvw6Ehun332mQYPHux8PmXKFEnSmDFjtHDhQn355Zd6+eWXlZeXp+joaA0bNkyzZ892GYVt8eLFmjRpkoYOHSpvb28lJibqqaeeavBzAQAA9Y+LjAAAAAAAAAAas/j4eI0aNUqdO3fW3r179ac//UnDhw9Xenq6fHx8lJ2drfDwcJfX+Pr6KiwsTNnZ2eUes6ioSEVFRc7nBQUF9XoOAAAAnuDRTm6DBg2SMabC7R999FGVxwgLC1Nqaqo7ywIAAAAAAAAAAEAz5fii5fLlnq0DTdPo0aOdj3v16qXevXvrwgsv1Pr16zV06NBaHXPu3LmaOXOmu0oEAACwJY92cms0/P2lf/3rzGMAAADYHxkOAAAAdkdmBQCg2evSpYvatm2rPXv2aOjQoYqMjFRubq7LPqdPn9aRI0cUGRlZ7jGmTp3qnDFLskZya9++fb3W3eSR0wAAsB06uVWHn5+UnOzpKgAAAFATZDgAAADYHZkVAGzBMXIb4Ak//PCDDh8+rKioKElSTEyM8vLylJGRoX79+kmS1q5dq9LSUg0YMKDcYwQEBCggIKDBam4WyGkAANgOndwAAAAAAECTwLRSAAAAADytsLBQe/bscT7PyspSZmamwsLCFBYWppkzZyoxMVGRkZHau3evHnroIV100UWKi4uTJHXv3l3x8fG699579eyzz6q4uFiTJk3S6NGjFR0d7anTAgAA8Dg6uVVHSYn08cfW42uvlXx8PFsPAAAAqkaGAwAAgN2RWQHYFCObAbX32WefafDgwc7njmlEx4wZo4ULF+rLL7/Uyy+/rLy8PEVHR2vYsGGaPXu2y0hsixcv1qRJkzR06FB5e3srMTFRTz31VIOfS7NGTgMAwHbo5FYdJ09KjjBaWCgFBXm2HgAAAFSNDAegmeFGJAA0QmRWAACanEGDBskYU+H2jz76qMpjhIWFKTU11Z1loabIaQAA2A6d3AAAaGK4wQ0AAAAAAAAAAAAAaEro5AYAAAAAAAAAAAC+PAkAAADAtrw9XQAAAAAAAAAAAAAAAAAAABVhJDcAAAAAABoxRtsAAAAAAAAA0NQ5roMuX+7ZOuA5jOQGAAAAAACapIQEOgECAAAAAAAAQFNAJzcAAAAAAAAAAAAAAAAAtscXW5svpiutDj8/6fHHzzwGAACA/ZHhAAAAYHdkVgAAAHsipwEAYDt0cqsOf3/pwQc9XQUAAM0a38hAjZHhAAAAYHdkVgAAAHsipwGwEcc9suXLPVsH4GlMVwoAAAAAAAAAAAAAAAAAsC1GcquOkhLp88+tx5dfLvn4eLYeAAAAVI0MBwAAALsjswIAANgTOQ0AANuhk1t1nDwpXXml9biwUAoK8mw9AAAAqBoZDgAAAHZHZgVgE44psAAA/x85DQAA22G6UgAAAAAAAAAAAAAAAACAbTGSGwAAAAAAAAAAAAAAAGBjjL6L5o6R3AAAAAAAAAAAAAAAAAAAtkUnNwAAAAAAAAAAAAAAAACAbTFdKQAATQRDFAMAAAAAAAAAAAAAmiJGcgMAoAmggxsAAAAAAAAAAAAAoKliJLfq8POTZsw48xgAAAD2R4YDAACA3ZFZAQAA7ImcBgCA7dDJrTr8/aVHH/V0FQAAAKgJMhwAAADsjswKAABgT+Q0AABsh05uAAA0YkxTCgAAAAAAAAAAAABo6rw9XUCjUFoq7dhhLaWlnq4GAAAA1UGGA9CE0dEdAJoIMisAAIA9kdMAALAdRnKrjhMnpEsvtR4XFkpBQZ6tBwAAAFUjwwEAAMDuyKwAAAD2RE4D4EGOL7guX+7ZOgC7YSQ3AAAAAAAAAAAAAAAAAIBt0ckNAAAAAAAAAAAAAAAAAGBbTFcKAAAAAACaFMeUDgAAAAAAAACApoGR3AAAAAAAAAAAAAAAAAAAtkUnNwAAAAAAAAAAAAAAAACAbdHJDQAAAAAAAAAAAAAAAABgW76eLqBR8POT/vCHM48BAABgf2Q4AAAA2B2ZFQAAwJ7IaQAA2A6d3KrD31/6+989XQUAAABqggwHAAAAuyOzAgAA2BM5DYANJCR4ugLAXpiuFAAAAAAAAAAAAAAAAABgW4zkVh2lpdL+/dbjDh0kb/oGAgA8w/GNjeXLPVsH0CiQ4QAAAGB3ZFYAAAB7IqcBAGA7/DWujhMnpM6dreXECU9XAwAAzsFwzSgXGQ4AADRRGzduVEJCgqKjo+Xl5aV33nnHZbsxRtOnT1dUVJQCAwMVGxurb7/91mWfI0eOKCkpScHBwQoNDdX48eNVWFjYgGcBSWRWALC5hASuOwHNFjkNAADboZMbAAAAysXNUwAAAHs6duyYLrvsMi1YsKDc7Y8//rieeuopPfvss9q6dauCgoIUFxenkydPOvdJSkrSjh07tHr1aq1YsUIbN27UhAkTGuoUAAAAAAAAgBqhkxsAAADKxc1TAAAAexo+fLjmzJmjW2+9tcw2Y4zmz5+vadOmacSIEerdu7deeeUVHTx40PmlhV27dmnlypX697//rQEDBuiaa67R008/rSVLlujgwYMNfDYAAAAAAABA1ejkBgAAgHJx8xQAAKDxycrKUnZ2tmJjY53rQkJCNGDAAKWnp0uS0tPTFRoaqv79+zv3iY2Nlbe3t7Zu3drgNQMAAAAAAABVoZMbAABotBISrAUNj5unAAAA9pSdnS1JioiIcFkfERHh3Jadna3w8HCX7b6+vgoLC3PuU56ioiIVFBS4LACAxo9rKwAAAAAaAzq5AQAAoMbq6+YpN04BAADsa+7cuQoJCXEu7du393RJAAAAAAAAaCY82slt48aNSkhIUHR0tLy8vJxTWzkYYzR9+nRFRUUpMDBQsbGx+vbbb132OXLkiJKSkhQcHKzQ0FCNHz9ehYWFDXgWAAAAcBdunAIAANRNZGSkJCknJ8dlfU5OjnNbZGSkcnNzXbafPn1aR44cce5TnqlTpyo/P9+5HDhwwM3VAwAAAAAAAOXzaCe3Y8eO6bLLLtOCBQvK3f7444/rqaee0rPPPqutW7cqKChIcXFxOnnypHOfpKQk7dixQ6tXr9aKFSu0ceNGTZgwwb2F+vpKv/udtfj6uvfYAAAAjVB93Tx1641TMhwAAGiGOnfurMjISKWlpTnXFRQUaOvWrYqJiZEkxcTEKC8vTxkZGc591q5dq9LSUg0YMKDCYwcEBCg4ONhlQR2RWQEAAOyJnAYAgO149C/y8OHDNXz48HK3GWM0f/58TZs2TSNGjJAkvfLKK4qIiNA777yj0aNHa9euXVq5cqW2bdum/v37S5Kefvpp3XjjjXriiScUHR3tnkIDAqQKOuIBAAA0R2ffPO3Tp4+kMzdPJ06cKMn15mm/fv0kVX3zNCAgQAEBAe4pkgwHAACaqMLCQu3Zs8f5PCsrS5mZmQoLC1OHDh10//33a86cObr44ovVuXNnPfLII4qOjtbIkSMlSd27d1d8fLzuvfdePfvssyouLtakSZM0evRo911PQ/WQWQEAAOyJnAYAgO14dCS3ymRlZSk7O1uxsbHOdSEhIRowYIDS09MlSenp6QoNDXV2cJOk2NhYeXt7a+vWrQ1eMwAAQFNSWFiozMxMZWZmSjpz83T//v3y8vJy3jx977339NVXX+k3v/lNhTdPP/30U23atImbpwAAAG7w2WefqW/fvurbt68kacqUKerbt6+mT58uSXrooYc0efJkTZgwQVdccYUKCwu1cuVKtWjRwnmMxYsXq1u3bho6dKhuvPFGXXPNNXr++ec9cj4AAAAAAABAVWzbyS07O1uSFBER4bI+IiLCuS07O1vh4eEu2319fRUWFubcpzxFRUUqKChwWSpljPTTT9ZiTC3OBgAAoPFp9DdPyXAAAKCJGjRokIwxZZZFixZJkry8vDRr1ixlZ2fr5MmTWrNmjS655BKXY4SFhSk1NVVHjx5Vfn6+XnrpJbVq1coDZ9PMkVkBAGhyNm7cqISEBEVHR8vLy0vvvPOOy3ZjjKZPn66oqCgFBgYqNjZW3377rcs+R44cUVJSkoKDgxUaGqrx48ersLCwAc8C5DQAsL+EBGtB89EsJxCfO3euZs6cWf0XHD8uOTrTFRZKQUH1UxgAANVEYENDcNw8rYjj5umsWbMq3Mdx89QjyHAAAACwOzIrAA/i+hJQP44dO6bLLrtM99xzj0aNGlVm++OPP66nnnpKL7/8snNq+bi4OO3cudP55dGkpCQdOnRIq1evVnFxscaNG6cJEyZ47jpbc0ROAwDAdmw7kltkZKQkKScnx2V9Tk6Oc1tkZKRyc3Ndtp8+fVpHjhxx7lOeqVOnKj8/37kcOHDAzdUDAAAAAAAAAACgKaBDIGpi+PDhmjNnjm699dYy24wxmj9/vqZNm6YRI0aod+/eeuWVV3Tw4EHniG+7du3SypUr9e9//1sDBgzQNddco6efflpLlizRwYMHG/hsAAAA7MO2ndw6d+6syMhIpaWlOdcVFBRo69atiomJkSTFxMQoLy9PGRkZzn3Wrl2r0tJSDRgwoMJjBwQEKDg42GUBAAAAAAAAAAAAgPqSlZWl7OxsxcbGOteFhIRowIABSk9PlySlp6crNDRU/fv3d+4TGxsrb29vbd26tdzjFhUVqaCgwGUBAABoajw6XWlhYaH27NnjfJ6VlaXMzEyFhYWpQ4cOuv/++zVnzhxdfPHFzuF6o6OjNXLkSElS9+7dFR8fr3vvvVfPPvusiouLNWnSJI0ePVrR0dEeOisAAAAAAAAAAAAAcJWdnS1JioiIcFkfERHh3Jadna1wxzSZ/5+vr6/CwsKc+5xr7ty5mjlzZj1UDAAAYB8eHcnts88+U9++fdW3b19J0pQpU9S3b19Nnz5dkvTQQw9p8uTJmjBhgq644goVFhZq5cqVzvnoJWnx4sXq1q2bhg4dqhtvvFHXXHONnn/+eY+cDwAAAAAAAAAAAAA0pKlTpyo/P9+5HDhwwNMlAQAAuJ1HR3IbNGiQjDEVbvfy8tKsWbM0a9asCvcJCwtTampqfZQHAAAAAAAAAAAAAG4RGRkpScrJyVFUVJRzfU5Ojvr06ePcJzc31+V1p0+f1pEjR5yvP1dAQIACAgLqp2gAAACb8OhIbgAAAAAAoHYSEqwFAAAAqA7yI+B5nTt3VmRkpNLS0pzrCgoKtHXrVsXExEiSYmJilJeXp4yMDOc+a9euVWlpqQYMGNDgNQMAANiFR0dyazR8faUxY848BgAAgP2R4QAAAGB3ZFYAAJqcwsJC7dmzx/k8KytLmZmZCgsLU4cOHXT//fdrzpw5uvjii9W5c2c98sgjio6O1siRIyVJ3bt3V3x8vO699149++yzKi4u1qRJkzR69GhFR0d76KyaIXIaAAC2w1/k6ggIkBYt8nQVAAAAqAkyHAAAAOyOzArAAxjNDahfn332mQYPHux8PmXKFEnSmDFjtGjRIj300EM6duyYJkyYoLy8PF1zzTVauXKlWrRo4XzN4sWLNWnSJA0dOlTe3t5KTEzUU0891eDn0qyR0wAAsB06uQEAAAAAAAAAAACAGwwaNEjGmAq3e3l5adasWZo1a1aF+4SFhSk1NbU+ygMA2BhfRgAqRye36jBGOn7cetyypeTl5dl6AAAAUDUyHAAAAOyOzAoAAGBP5DQAAGzH29MFNArHj0utWlmLI8wAAADA3shwAAAAsDsyKwAAgD2R0wAAsB06uQEAgCYlIYHhnAEAAAAAAAAAAACgKaGTGwAAAAAANkcnbgAAAAAAAABAc+br6QIAAADcgRv/AAAAAAAAAAAAANA0MZIbAAAAAABo0hgJDwAAAAAAAAAaNzq5AQAAAAAAAAAAAAAAAABsi05uAAAAAAAAAAAAAAAAAADb8vV0AY2Cj490221nHgMAAMD+yHAAAACwOzIrAACAPZHTAACwHTq5VUeLFtLSpZ6uAgAAADVBhgPQBCUkeLoCAIBbkVkBAADsiZwGAIDtMF0pAAAAAAAAAAAAAAAAAMC26OQGAAAAAAAAAAAAAAAAALAtOrlVx7FjkpeXtRw75ulqAAAAUB1kOADAORISmPIVgM2QWQEAAOyJnAYAgO3QyQ0AAAAAAAAAAAAAAAAAYFt0cgMAoJFg1BEAAAAAAAAAAAAAQHPk6+kCAAAAAABA+ejkDgAAAAAAADRNXPsDaoaR3AAAAAAAAAAAAAAAAAAAtkUnNwAAAAAAAAAAAAAAAACNTkICo+I1F3RyAwAAAAAAAAAAAAAAAADYlq+nC2gUfHykG2888xgAAAD2R4YDAACA3ZFZAaDRcIwOsny5Z+sA0EDIaQAA2A6d3KqjRQvp/fc9XQUAAABqggwHAAAAuyOzAgAA2BM5DQAA22G6UgAAbIr54+uG9gMAAAAAAM0Z10YAAAAANCWM5AYAAAAAgM1wMxIAAAAAAAAAgDMYya06jh2TgoKs5dgxT1cDAGgGzr6xzbdugVoiwwEAAMDuyKwAAAD2RE4DAMB2GMmtuo4f93QFAAAAqCkyHAAAAOyOzAoAAGBP5DQA9YTBLYDaYSQ3AAAAAADQrDBSLgAAAAAAAAA0LnRyAwAAAAAAAAAAAAAAAADYFp3cAAAAAAAAAAAAAAAAAAC25evpAgAAAAAAAAAAAFA/mKYdAAAAQFPASG4AAAAAAAAAAABNCB3bAAAA0NwkJJCDmzpGcqsOb2/p+uvPPAYAAI1GQoK0fLmnq4BHkOEANCKOiy/8zQKAZobMCgAAYE/kNAAAbIdObtURGCitX+/pKgAAAFATZDgAAADYHZkVAADAnshpAADYDt3OAQAAAABAs8QUBgAAAAAAAADQONDJDQAAAAAAAAAAAAAAAABgW0xXWh3HjkmdOlmP9+2TgoI8WQ0AoAljJBHAjchwABohsgAANDNkVgAAAHsipwEAYDt0cquun3/2dAUAAKCWHB0Gli/3bB3wADIcAAAA7I7MCgAAYE/kNAAAbIXpSgEAAAAAAIAm5NFHH5WXl5fL0q1bN+f2kydPKjk5WW3atFGrVq2UmJionJwcD1YMAEDjkZDACMwAAACAJ9DJDQAAALXCzVMAAAD76tmzpw4dOuRcPvnkE+e2Bx54QMuXL9fSpUu1YcMGHTx4UKNGjfJgtQAAND50dgMAAAAaFtOVAgAAoNZ69uypNWvWOJ/7+p6Jlw888IDef/99LV26VCEhIZo0aZJGjRqlTZs2eaJUAACAZsXX11eRkZFl1ufn5+vFF19UamqqhgwZIklKSUlR9+7dtWXLFg0cOLChSwUAAAAAAACqZOuR3BgdBADQXPDNTzRWjpunjqVt27aSztw8ffLJJzVkyBD169dPKSkp2rx5s7Zs2eLhqgEAAJq+b7/9VtHR0erSpYuSkpK0f/9+SVJGRoaKi4sVGxvr3Ldbt27q0KGD0tPTPVUuAAAAAAAAUClbd3KTmFoBAADAztx987SoqEgFBQUuCwAAAGpmwIABWrRokVauXKmFCxcqKytL1157rY4ePars7Gz5+/srNDTU5TURERHKzs6u9LhkNQAAAAAAYHcMLtJ02b6Tmy1GB/H2lvr3txZv2zcZAABAg6iPm6dz585VSEiIc2nfvn3tCyTDAQCAZmr48OH61a9+pd69eysuLk4ffPCB8vLy9Oabb9bpuG7NarCQWQEAaHaYyaqRIKcBAGA7vp4uoCqO0UFatGihmJgYzZ07Vx06dKhydJCBAwe6r4jAQGnbNvcdDwAAoAkYPny483Hv3r01YMAAdezYUW+++aYCAwNrdcypU6dqypQpzucFBQW1v3lKhgMAVJPjm53Ll3u2DqC+hIaG6pJLLtGePXt0ww036NSpU8rLy3P5QkJOTo4iIyMrPY5bsxosZFYAbsaIFUDj0LNnT61Zs8b53Nf3zC3bBx54QO+//76WLl2qkJAQTZo0SaNGjdKmTZs8UWrzRU4DUA/IakDd2LqTm2N0kK5du+rQoUOaOXOmrr32Wm3fvr3OUysUFRU5nzO1AgAAQN254+ZpQECAAgICGqBaAACA5qOwsFB79+7V3XffrX79+snPz09paWlKTEyUJO3evVv79+9XTExMpcchqwEAALiHYyarczlmskpNTdWQIUMkSSkpKerevbu2bNni3kE+AAD1ji9WAu5l67FVmVoBANDUMSc8mhLHzdOoqCiXm6cO1b15CgAAgLr5wx/+oA0bNmjfvn3avHmzbr31Vvn4+OjOO+9USEiIxo8frylTpmjdunXKyMjQuHHjFBMTw01TAACABuKYyapLly5KSkrS/v37JanKmawqUlRUpIKCApcFAACgqbF1J7dznT06SGRkpHN0kLNVd2qF/Px853LgwIHK3/j4calTJ2s5frxO5wAAANBU2P7mKRkOAAA0Uz/88IPuvPNOde3aVbfffrvatGmjLVu2qF27dpKkefPm6eabb1ZiYqKuu+46RUZG6u233/Zw1c0UmRUAgGbHMZPVypUrtXDhQmVlZenaa6/V0aNHaz2TFQN81ANyGgAAtmPr6UrP5bGpFYyRvv/+zGMAAAA4b54ePnxY7dq10zXXXFPm5qm3t7cSExNVVFSkuLg4PfPMMw1XIBkOAAA0U0uWLKl0e4sWLbRgwQItWLCggSpChcisAAA0O8OHD3c+7t27twYMGKCOHTvqzTffVGBgYK2OOXXqVE2ZMsX5vKCggI5udUVOAwDAdmzdye0Pf/iDEhIS1LFjRx08eFAzZswod3SQsLAwBQcHa/LkyUytAAAA0EC4eQoAAAAAAADUzdkzWd1www3OmazOHs2tqpmsajzABwAAQCNk6+lKmVoBAAAAAAAAAAAAQFPlmMkqKirKZSYrh+rOZAUAANDU2XokN0YHAQAA9SUhwfrv8uWerQMAAAAAAABA88FMVgAAALVj605uAAAAAAA0ZY5O1wAAAEBN8OU9+zg30/MzQVUcM1kdPnxY7dq10zXXXFNmJitvb28lJiaqqKhIcXFxeuaZZzxcNQAAgOfRyQ0AAAAAgAZG5zYAAAAAaJ6YyQoAmh+uBQLuQSe36vDyknr0OPMYAAAA9keGAwAAgN2RWQHUESO6AUA9IacBAGA7dHKrjpYtpR07PF0FAACoIy78NjNkOAAAANgdmRWAmzA6CAC4GTkNQB2QzYD64e3pAgAAaK4IuAAAAAAAAAAAAAAAVI2R3AAAAAAAAAAAABoBvjQJAAAAoLliJLfqOH5c6tnTWo4f93Q1AAAAqA4yHAAAAOyOzAoAAGBP5DQAAGyHkdyqwxhp584zjwEAAGB/ZDgANuAYaWP5cs/Wgerh5wWgwZFZAQAA7ImcBgCNHtf6mh5GcgMAoIEkJDClBAAAAAAAAAAAAAAANUUnNwAAAAAAAAAAAAAAAKAaGNiiceHn1XTQyQ0AAAAAAAAAAABwA26gAgAAAPWDTm4AAAAAAABn4dudAAAAAAAAAGAvdHIDAAAAAAAoB53dAAAAUBvkSAAAAMD9fD1dQKPg5SV17HjmMQAAAOyPDAcAAAC7I7MCAADYEzkNAADboZNbdbRsKe3b5+kqAAAAUBNkOAAAANgdmRUAAMCeyGkAANgO05UCAAAAAAAAAAAAAAAAAGyLTm4AAAAAANSzhARrAQAAAAAAANC0cO0PaBhMV1odJ05I111nPd64UQoM9Gw9AIBGjZALNBAyHAAAAOyOzAoAAGBP5DQAtcA9QHtz/HyWL/dsHag9OrlVR2mp9NlnZx4DAADA/shwAAAAsDsyKwAAgD2R0wAAsB06uQEAgGanvG/S8O0NAIA7VfStTb7NCQAAAAAAADQNXOsDGpa3pwsAAKApSkgg2AIAAAAAAAAAAACNHff9AHtgJDcAAAAAANyEi10AAAAAAAAAALgfI7kBAFCPuNENAAAAAAAAd+A6EwAAAIDmjE5uAAAAAAAAAAAAAAAAAADbYrrS6mrb1tMVAABsLiFBWr7c01UAcEGGAwAAgN2RWQFUgRHcGi/Hz45rhkAjRU4DgGaBzNZ40MmtOoKCpJ9+8nQVAACb4kIjYFNkOAAAANgdmRUAAMCeyGkA0GTRqa3xopMbAABuRIc3AACaFy6IAAAAoL5wnQkAAAAAzqCTGwAA9YwLkgAAAI0bnRkBAAAAAAAAwLPo5FYdJ05Iw4dbjz/8UAoM9Gw9AADAbeiE2ISR4QAAAGB3ZFYAaBb40gTQCJHTAACwHTq5VUdpqbRhw5nHAACgyUpI4IJjk0GGA9CA6DQNAKgVMiuAs5ApAcBGyGkAANiOt6cLAAAAAAAAAAAAAAAAAACgInRyAwAAAAAAAAAAAAAAANBsJSQwurLdMV0pAAA1cHawYUpLAACaD0cG4O8/AAAAAAAA0DzQ4alp4+fb+DCSGwAAAAAAAAAAANBAGCUEAAAAqDlGcgMAoJa4ENX0MWoPAKAi5AAAAAC4A7kSAAAAAKqHTm7V1bKlpysAAABATZHhAAAAYHdkVgAAAHsipwE4B19QADyLTm7VERQkHTvm6SoAAABQE2Q4ADXA6J0AAI8gswIAANgTOQ0AANvx9nQBAAAAjUlCAt/UAQCguTs7D5ANAABAdZAZAAAAAKBuGMkNAIByMJoLzsbnAQDgwI1JnO3szwN5AQAAAAAAoGngGmDzxnU++6KTW3WcPCklJlqP33pLatHCs/UAABocYRZohMhwAAAAsDsyK9DscMMMZ0tI4LMA2BY5DWgWuP8HNC50cquOkhLpgw/OPAYAAID9keEAlIObigAAWyGzAgAA2BM5DWjS6NyGmuCasn3QyQ0AAOAcFf3jhinJAKDpOfd3/rm/37nghZoiIwAA0HycmxVr8vefnNk8VfZzJ0cCAOB+dclrwLnIa57n7ekCAADwtIQELiwCAABX5AMAAIDmpT7yH3kSAACgYXAtD2gemkwntwULFqhTp05q0aKFBgwYoE8//dTTJQEAbKSicHvuyFzn7kcoRlX4fFQPWQ2AJ5X395y/8agNPjdoishpAAB4FhkTlSGrAUDNnH2vj7+vQNPTJDq5vfHGG5oyZYpmzJihzz//XJdddpni4uKUm5vr6dIAAACaPbIagIZSVWd1LmzBE7ioCjsjpwGAe/HlCgDuRFYDAPcjm6Em+LzYj6+nC3CHJ598Uvfee6/GjRsnSXr22Wf1/vvv66WXXtIf//hHD1cHAPCUykIHgQQNxfFZW77cs3V4ElkNQG3xOxSNWXk3uCU+z7AXchqA5qI2f4fP/VvueG1CAn/P0TDK+9ySKZsXshoAO/PU3yTu78EOKvq3Aupfo+/kdurUKWVkZGjq1KnOdd7e3oqNjVV6enq5rykqKlJRUZHzeX5+viSpoKCg/Dc5duzM44ICqaSk7oUDAOrk9tsr3vbmm9Z/i4vLbouPr5960Lyd+7lyfAalM5/DimKGtc3aaIxxc2WeV9OsVuOcVhkyHNBoOP6un/37U6r4d+i5+5+bCxz7l5cFAE9zfD4ryrPn/n8Az2uqWa1BrqmhamRWoEE4cqHj3+/n/r09++9yRdeOzl5fVd7k+hPq4tzPV3mfp4o+y81NU81pkoevqcFCTgMqVd3rdjVV2f0/wK4qu0/YnNVHVmv0ndx+/vlnlZSUKCIiwmV9RESEvv7663JfM3fuXM2cObPM+vbt21f9htHRtaoTANBwQkI8XQGau/I+g9X5XB49elQhTewDXNOsVqecVhkyHNAoVPQr0F3rATuo6vPJ59e+mlpWa/BraqgamRVoMHX9dd6E/hzAhmry+eKzaGlqOU2y0TU1WMhpQIW4PgeUxefflTuzWqPv5FYbU6dO1ZQpU5zPS0tLdeTIEbVp00ZeXl4NUkNBQYHat2+vAwcOKDg4uEHe045oBwvtYKEdLLSDhXaw0A6Wpt4OxhgdPXpU0VwsIafZCO1goR0stMMZtIWFdrDQDpam3g5ktTPIavZBO1hoBwvtYKEdLLSDhXawNPV2IKedQU6zD9rBQjtYaIczaAsL7WChHSxNvR3qI6s1+k5ubdu2lY+Pj3JyclzW5+TkKDIystzXBAQEKCAgwGVdaGhofZVYqeDg4Cb5Ya0p2sFCO1hoBwvtYKEdLLSDpSm3Q1P7tqlDTbMaOc1+aAcL7WChHc6gLSy0g4V2sDTldmiKWY1rak0D7WChHSy0g4V2sNAOFtrB0pTboSnmNIlrak0B7WChHSy0wxm0hYV2sNAOlqbcDu7Oat5uPZoH+Pv7q1+/fkpLS3OuKy0tVVpammJiYjxYGQAAAMhqAAAA9kROAwAAsC+yGgAAQFmNfiQ3SZoyZYrGjBmj/v3768orr9T8+fN17NgxjRs3ztOlAQAANHtkNQAAAHsipwEAANgXWQ0AAMBVk+jkdscdd+inn37S9OnTlZ2drT59+mjlypWKiIjwdGkVCggI0IwZM8oMHdzc0A4W2sFCO1hoBwvtYKEdLLRD49bYshqfNwvtYKEdLLTDGbSFhXaw0A4W2qHxamw5TeLz5kA7WGgHC+1goR0stIOFdrDQDo1bY8tqfN4stIOFdrDQDmfQFhbawUI7WGiHmvMyxhhPFwEAAAAAAAAAAAAAAAAAQHm8PV0AAAAAAAAAAAAAAAAAAAAVoZMbAAAAAAAAAAAAAAAAAMC26OQGAAAAAAAAAAAAAAAAALAtOrkBAAAAAAAAAAAAAAAAAGyLTm5usmDBAnXq1EktWrTQgAED9Omnn1a479tvv63+/fsrNDRUQUFB6tOnj1599VWXfcaOHSsvLy+XJT4+vr5Po85q0g5nW7Jkiby8vDRy5EiX9cYYTZ8+XVFRUQoMDFRsbKy+/fbbeqjcvdzdDs3h87Bo0aIy59iiRQuXfRrr50Fyf1s0h8+EJOXl5Sk5OVlRUVEKCAjQJZdcog8++KBOx7QDd7fDo48+Wubz0K1bt/o+jTqrSTsMGjSozDl6eXnppptucu7TmH9HoP6R1SxkNQtZzUJWs5DTLOQ0CznNQk5DQyKnWchpFnKahZx2BlnNQlazkNUsZDU0JLKahaxmIatZyGoWcpqFnGYhp1nIaQ3AoM6WLFli/P39zUsvvWR27Nhh7r33XhMaGmpycnLK3X/dunXm7bffNjt37jR79uwx8+fPNz4+PmblypXOfcaMGWPi4+PNoUOHnMuRI0ca6pRqpabt4JCVlWXOP/98c+2115oRI0a4bPvrX/9qQkJCzDvvvGO++OILc8stt5jOnTubEydO1OOZ1E19tENz+DykpKSY4OBgl3PMzs522acxfh6MqZ+2aA6fiaKiItO/f39z4403mk8++cRkZWWZ9evXm8zMzFof0w7qox1mzJhhevbs6fJ5+OmnnxrqlGqlpu1w+PBhl/Pbvn278fHxMSkpKc59GuvvCNQ/spqFrGYhq1nIahZymoWcZiGnWchpaEjkNAs5zUJOs5DTziCrWchqFrKahayGhkRWs5DVLGQ1C1nNQk6zkNMs5DQLOa1h0MnNDa688kqTnJzsfF5SUmKio6PN3Llzq32Mvn37mmnTpjmfjxkzpswferurTTucPn3aXHXVVebf//53mXMuLS01kZGR5u9//7tzXV5engkICDCvv/56vZyDO7i7HYxpHp+HlJQUExISUuHxGuvnwRj3t4UxzeMzsXDhQtOlSxdz6tQptx3TDuqjHWbMmGEuu+wyd5dar+r6s5s3b55p3bq1KSwsNMY07t8RqH9kNQtZzUJWs5DVLOQ0CznNQk6zkNPQkMhpFnKahZxmIaedQVazkNUsZDULWQ0NiaxmIatZyGoWspqFnGYhp1nIaRZyWsNgutI6OnXqlDIyMhQbG+tc5+3trdjYWKWnp1f5emOM0tLStHv3bl133XUu29avX6/w8HB17dpVEydO1OHDh91ev7vUth1mzZql8PBwjR8/vsy2rKwsZWdnuxwzJCREAwYMqFbbekJ9tINDc/g8FBYWqmPHjmrfvr1GjBihHTt2OLc1xs+DVD9t4dDUPxPvvfeeYmJilJycrIiICF166aV67LHHVFJSUutjelp9tIPDt99+q+joaHXp0kVJSUnav39/vZ5LXbjjZ/fiiy9q9OjRCgoKktR4f0eg/pHVLGQ1C1nNQlazkNMs5DQLOc1CTkNDIqdZyGkWcpqFnHYGWc1CVrOQ1SxkNTQkspqFrGYhq1nIahZymoWcZiGnWchpDYdObnX0888/q6SkRBERES7rIyIilJ2dXeHr8vPz1apVK/n7++umm27S008/rRtuuMG5PT4+Xq+88orS0tL0t7/9TRs2bNDw4cPL/I9tF7Vph08++UQvvviiXnjhhXK3O15X07b1pPpoB6l5fB66du2ql156Se+++65ee+01lZaW6qqrrtIPP/wgqXF+HqT6aQupeXwmvvvuO/3nP/9RSUmJPvjgAz3yyCP6xz/+oTlz5tT6mJ5WH+0gSQMGDNCiRYu0cuVKLVy4UFlZWbr22mt19OjRej2f2qrrz+7TTz/V9u3b9dvf/ta5rrH+jkD9I6tZyGoWspqFrGYhp1nIaRZymoWchoZETrOQ0yzkNAs57QyymoWsZiGrWchqaEhkNQtZzUJWs5DVLOQ0CznNQk6zkNMajq+nC2iuWrdurczMTBUWFiotLU1TpkxRly5dNGjQIEnS6NGjnfv26tVLvXv31oUXXqj169dr6NChHqrafY4ePaq7775bL7zwgtq2bevpcjymuu3Q1D8PkhQTE6OYmBjn86uuukrdu3fXc889p9mzZ3uwsoZXnbZoDp+J0tJShYeH6/nnn5ePj4/69eunH3/8UX//+981Y8YMT5fXYKrTDsOHD3fu37t3bw0YMEAdO3bUm2++Wek3pBqrF198Ub169dKVV17p6VLQhJHVyGoSWe1sZDULOc1CTrOQ08oip6EhkNPIaRI57WzktDPIahaymoWsVhZZDQ2BrEZWk8hqZyOrWchpFnKahZxWFjmt+ujkVkdt27aVj4+PcnJyXNbn5OQoMjKywtd5e3vroosukiT16dNHu3bt0ty5c50h71xdunRR27ZttWfPHlv+Eq9pO+zdu1f79u1TQkKCc11paakkydfXV7t373a+LicnR1FRUS7H7NOnTz2cRd3VRztceOGFZV7X1D4P5fHz81Pfvn21Z88eSWqUnwepftqiPE3xMxEVFSU/Pz/5+Pg413Xv3l3Z2dk6deqUW9q2odVHO/j7+5d5TWhoqC655JJKPzOeVJef3bFjx7RkyRLNmjXLZX1j/R2B+kdWs5DVLGQ1C1nNQk6zkNMs5DQLOQ0NiZxmIadZyGkWctoZZDULWc1CVrOQ1dCQyGoWspqFrGYhq1nIaRZymoWcZiGnNRymK60jf39/9evXT2lpac51paWlSktLc+mNXJXS0lIVFRVVuP2HH37Q4cOHXT68dlLTdujWrZu++uorZWZmOpdbbrlFgwcPVmZmptq3b6/OnTsrMjLS5ZgFBQXaunVrjdq2IdVHO5SnqX0eylNSUqKvvvrKeY6N8fMg1U9blKcpfiauvvpq7dmzx/kPH0n65ptvFBUVJX9/f7f9/m1I9dEO5SksLNTevXub1OfBYenSpSoqKtKvf/1rl/WN9XcE6h9ZzUJWs5DVLGQ1CznNQk6zkNMs5DQ0JHKahZxmIadZyGlnkNUsZDULWc1CVkNDIqtZyGoWspqFrGYhp1nIaRZymoWc1oAM6mzJkiUmICDALFq0yOzcudNMmDDBhIaGmuzsbGOMMXfffbf54x//6Nz/scceM6tWrTJ79+41O3fuNE888YTx9fU1L7zwgjHGmKNHj5o//OEPJj093WRlZZk1a9aYyy+/3Fx88cXm5MmTHjnH6qhpO5xrzJgxZsSIES7r/vrXv5rQ0FDz7rvvmi+//NKMGDHCdO7c2Zw4caI+T6VO3N0OzeXzMHPmTPPRRx+ZvXv3moyMDDN69GjTokULs2PHDuc+jfHzYIz726K5fCb2799vWrdubSZNmmR2795tVqxYYcLDw82cOXOqfUw7qo92+P3vf2/Wr19vsrKyzKZNm0xsbKxp27atyc3NbfDzq67a/q685pprzB133FHuMRvr7wjUP7KahaxmIatZyGoWcpqFnGYhp1nIaWhI5DQLOc1CTrOQ084gq1nIahaymoWshoZEVrOQ1SxkNQtZzUJOs5DTLOQ0CzmtYdDJzU2efvpp06FDB+Pv72+uvPJKs2XLFue266+/3owZM8b5/M9//rO56KKLTIsWLcx5551nYmJizJIlS5zbjx8/boYNG2batWtn/Pz8TMeOHc29995r619cDjVph3OVF/JKS0vNI488YiIiIkxAQIAZOnSo2b17dz1V7z7ubIfm8nm4//77nftGRESYG2+80Xz++ecux2usnwdj3NsWzeUzYYwxmzdvNgMGDDABAQGmS5cu5i9/+Ys5ffp0tY9pV+5uhzvuuMNERUUZf39/c/7555s77rjD7Nmzp6FOp9Zq2g5ff/21kWRWrVpV7vEa8+8I1D+ymoWsZiGrWchqFnKahZxmIadZyGloSOQ0CznNQk6zkNPOIKtZyGoWspqFrIaGRFazkNUsZDULWc1CTrOQ0yzkNAs5rf55GWOMZ8eSAwAAAAAAAAAAAAAAAACgfN6eLgAAAAAAAAAAAAAAAAAAgIrQyQ0AAAAAAAAAAAAAAAAAYFt0cgMAAAAAAAAAAAAAAAAA2Bad3AAAAAAAAAAAAAAAAAAAtkUnNwAAAAAAAAAAAAAAAACAbdHJDQAAAAAAAAAAAAAAAABgW3RyAwAAAAAAAAAAAAAAAADYFp3cAAAAAAAAAAAAAAAAAAC2RSc3AHWSnZ2tG264QUFBQQoNDa1wXX1YtGhRvR6/OfHy8tI777xT7f07deqk+fPn11s9AADAPchqTQNZDQCApoec1jSQ0wAAaJrIak0DWQ1oeujkBqBCY8eOlZeXV5klPj7euc+8efN06NAhZWZm6ptvvqlwXV2VFyruuOMOtx2/MsYYPf/88xowYIBatWql0NBQ9e/fX/Pnz9fx48fr/f3d6dFHH1WfPn3KrD906JCGDx9e7eNs27ZNEyZMcD6vaUgEAAB1R1azkNXKIqsBAOBZ5DQLOa0schoAAJ5HVrOQ1coiqwH25+vpAgDYW3x8vFJSUlzWBQQEOB/v3btX/fr108UXX1zpuvoQGBiowMDAen0PSbr77rv19ttva9q0afrXv/6ldu3a6YsvvtD8+fPVqVMnjRw5st5rqG+RkZE12r9du3b1VAkAAKgJshpZrTxkNQAAPI+cRk4rDzkNAAB7IKuR1cpDVgMaAQMAFRgzZowZMWJEhds7duxoJDmXMWPGlLvOGGN++eUXM378eNO2bVvTunVrM3jwYJOZmelyvPfee8/079/fBAQEmDZt2piRI0caY4y5/vrrXY7p+NWVkpJiQkJCjDHG7N6920gyu3btcjnmk08+abp06eJ8/tVXX5n4+HgTFBRkwsPDza9//Wvz008/VXiOb7zxhpFk3nnnnTLbSktLTV5enjHGmJKSEjNz5kxz/vnnG39/f3PZZZeZDz/80LlvVlaWkWTeeustM2jQIBMYGGh69+5tNm/e7NzHcT4rV6403bp1M0FBQSYuLs4cPHjQ5X1feOEF061bNxMQEGC6du1qFixY4LL9wIEDZvTo0ea8884zLVu2NP369TNbtmwxKSkpZdoxJSXFGGOMJLNs2TJjjDExMTHmoYcecjlmbm6u8fX1NRs2bDDGWD/7efPmOR+ffcyOHTuarKws4+XlZbZt2+ZynHnz5pkOHTqYkpKSCtscAABUD1mNrOZAVgMAwF7IaeQ0B3IaAAD2Q1YjqzmQ1YDGh05uACpUVcjLzc018fHx5vbbbzeHDh0yeXl55a4zxpjY2FiTkJBgtm3bZr755hvz+9//3rRp08YcPnzYGGPMihUrjI+Pj5k+fbrZuXOnyczMNI899pgxxpjDhw+bCy64wMyaNcscOnTIHDp0yBjjGvKMMaZ///5m2rRpLjX269fPue6XX34x7dq1M1OnTjW7du0yn3/+ubnhhhvM4MGDKzzHW265xXTt2rXKtnryySdNcHCwef31183XX39tHnroIePn52e++eYbY8yZkNetWzezYsUKs3v3bnPbbbeZjh07muLiYuf5+Pn5mdjYWLNt2zaTkZFhunfvbu666y7n+7z22msmKirKvPXWW+a7774zb731lgkLCzOLFi0yxhhz9OhR06VLF3Pttdeajz/+2Hz77bfmjTfeMJs3bzbHjx83v//9703Pnj2d7Xj8+HFjjGvI+9e//mU6dOhgSktLne/79NNPu6w7O+Tl5uY6A+OhQ4dMbm6uMcaYG264wfzud79zaafevXub6dOnV9meAACgamQ1spoDWQ0AAHshp5HTHMhpAADYD1mNrOZAVgMaHzq5AajQmDFjjI+PjwkKCnJZ/vKXvzj3GTFihPPbChWt+/jjj01wcLA5efKky34XXnihee6554wxVu/5pKSkCms5O1Q4nBvy5s2bZy688ELn83O/3TB79mwzbNgwl2McOHDASDK7d+8u9327d+9ubrnllgrrcoiOjnZpF2OMueKKK5whxxHy/v3vfzu379ixw6U+xzcN9uzZ49xnwYIFJiIiwvn8wgsvNKmpqS7vM3v2bBMTE2OMMea5554zrVu3dobnc82YMcNcdtllZdafHfIc31rYuHGjc3tMTIx5+OGHnc/P/Xmc/XqHN954w5x33nnOn3tGRobx8vIyWVlZ5dYGAABqhqxGVnMgqwEAYC/kNHKaAzkNAAD7IauR1RzIakDj4y0AqMTgwYOVmZnpsvzv//5vjY7xxRdfqLCwUG3atFGrVq2cS1ZWlvbu3StJyszM1NChQ+tU6+jRo7Vv3z5t2bJFkrR48WJdfvnl6tatm7OOdevWudTg2Oao41zGmCrft6CgQAcPHtTVV1/tsv7qq6/Wrl27XNb17t3b+TgqKkqSlJub61zXsmVLXXjhhS77OLYfO3ZMe/fu1fjx413OYc6cOS7t2LdvX4WFhVVZd0XatWunYcOGafHixZKkrKwspaenKykpqUbHGTlypHx8fLRs2TJJ0qJFizR48GB16tSp1rUBAABXZDWyGlkNAAB7IqeR08hpAADYF1mNrEZWAxonX08XAMDegoKCdNFFF9XpGIWFhYqKitL69evLbAsNDZUkBQYG1uk9JCkyMlJDhgxRamqqBg4cqNTUVE2cONGljoSEBP3tb38r81pH4DrXJZdcoq+//rrOtTn4+fk5H3t5eUmSSktLy93u2McRNAsLCyVJL7zwggYMGOCyn4+PjyT3tKMkJSUl6f/+7//09NNPKzU1Vb169VKvXr1qdAx/f3/95je/UUpKikaNGqXU1FT985//dEt9AADAQlYjq5HVAACwJ3IaOY2cBgCAfZHVyGpkNaBxYiQ3APXu8ssvV3Z2tnx9fXXRRRe5LG3btpVk9fBPS0ur8Bj+/v4qKSmp8r2SkpL0xhtvKD09Xd99951Gjx7tUseOHTvUqVOnMnUEBQWVe7y77rpL33zzjd59990y24wxys/PV3BwsKKjo7Vp0yaX7Zs2bVKPHj2qrLm6IiIiFB0dre+++65M/Z07d5ZktWNmZqaOHDlS7jGq244jRozQyZMntXLlSqWmplb5LQY/P79yj/vb3/5Wa9as0TPPPKPTp09r1KhR1ThTAADQkMhq7kFWAwAA7kZOcw9yGgAAqA9kNfcgqwGoCTq5AahUUVGRsrOzXZaff/65RseIjY1VTEyMRo4cqVWrVmnfvn3avHmz/vznP+uzzz6TJM2YMUOvv/66ZsyYoV27dumrr75y+cZBp06dtHHjRv3444+Vvv+oUaN09OhRTZw4UYMHD1Z0dLRzW3Jyso4cOaI777xT27Zt0969e/XRRx9p3LhxFQaf22+/XXfccYfuvPNOPfbYY/rss8/0/fffa8WKFYqNjdW6deskSQ8++KD+9re/6Y033tDu3bv1xz/+UZmZmbrvvvtq1FZVmTlzpubOnaunnnpK33zzjb766iulpKToySeflCTdeeedioyM1MiRI7Vp0yZ99913euutt5Seni7JasesrCxlZmbq559/VlFRUbnvExQUpJEjR+qRRx7Rrl27dOedd1ZaV6dOnZSWlqbs7Gz98ssvzvXdu3fXwIED9fDDD+vOO+902zctAACAhaxGViOrAQBgT+Q0cho5DQAA+yKrkdXIakAjZQCgAmPGjDGSyixdu3Z17jNixAgzZswYl9eVt66goMBMnjzZREdHGz8/P9O+fXuTlJRk9u/f79znrbfeMn369DH+/v6mbdu2ZtSoUc5t6enppnfv3iYgIMA4fnWlpKSYkJCQMnXffvvtRpJ56aWXymz75ptvzK233mpCQ0NNYGCg6datm7n//vtNaWlphe1QUlJiFi5caK644grTsmVLExwcbPr162f++c9/muPHjzv3efTRR835559v/Pz8zGWXXWY+/PBD5zGysrKMJPPf//7Xue6XX34xksy6desqPJ9ly5aZc39VL1682NlO5513nrnuuuvM22+/7dy+b98+k5iYaIKDg03Lli1N//79zdatW40xxpw8edIkJiaa0NBQI8mkpKQYY4yRZJYtW+byPh988IGRZK677roybdKxY0czb9485/P33nvPXHTRRcbX19d07NjRZd8XX3zRSDKffvppRU0MAABqgaxmIauR1QAAsBtymoWcRk4DAMCOyGoWshpZDWiMvIz5/5MdAwBQD2bPnq2lS5fqyy+/9HQpAAAAOAdZDQAAwJ7IaQAAAPZFVgM8g+lKAQD1orCwUNu3b9e//vUvTZ482dPlAAAA4CxkNQAAAHsipwEAANgXWQ3wLDq5AQDqxaRJk9SvXz8NGjRI99xzj6fLAQAAwFnIagAAAPZETgMAALAvshrgWUxXCgAAAAAAAAAAAAAAAACwLUZyAwAAAAAAAAAAAAAAAADYFp3cAAAAAAAAAAAAAAAAAAC2RSc3AAAAAAAAAAAAAAAAAIBt0ckNAAAAAAAAAAAAAAAAAGBbdHIDAAAAAAAAAAAAAAAAANgWndwAAAAAAAAAAAAAAAAAALZFJzcAAAAAAAAAAAAAAAAAgG3RyQ0AAAAAAAAAAAAAAAAAYFt0cgMAAAAAAAAAAAAAAAAA2Bad3AAAAAAAAAAAAAAAAAAAtkUnNwAAAAAAAAAAAAAAAACAbdHJDQAAAAAAAAAAAAAAAABgW3RyAwAAAACgGsaOHSsvLy916tTJ06UAAAAAAAAAANCs0MkNQLOxfv16eXl5lVl8fX0VFhamzp0767rrrtMDDzygt956S6dOnfJ0yQAAAI0SuQsAAKBp2rBhg0u+27x5c5WvqSgbOpZWrVrpkksu0d133621a9dWeqx9+/Y5Xzd27NhK9y0sLNR1113n3H/EiBHkTgAA0CjVx7W2Tp06uRzrlVdeqVYt9957r8vrqspkDp999pmmTp2qgQMH6vzzz1dAQICCg4N14YUX6rbbbtNzzz2nvLy8ah0LQPNFJzcAzV5JSYl++eUX7du3Tx9//LHmz5+v2267TRdccIHmzJmj06dPe7pEAACAJoHcBQAA0Li9/PLLLs+rezO0MseOHdO3336r1157TUOHDtWYMWNUUlJSp2MWFBQoLi5OH3/8sSQpMTFR//nPf+Tv71/negEAAOzCndfaXnvttSr3OXnypJYuXVqjGr///nslJCToiiuu0F//+ldt3bpVBw8e1KlTp3T06FF99913euutt/S///u/io6O1p///GedOHGiRu8BoPnwMsYYTxcBAA1h/fr1Gjx4sCRp4sSJ+t3vfufcVlhYqF9++UVffvml0tLStGbNGjl+PV555ZVasWKF2rVr55G6AQAAGhtyFwAAQNNz4sQJRURE6OjRo2rVqpUKCwt13nnn6dChQwoICKjwdZVlQ2OMjhw5ovT0dM2bN0+5ubmSpD//+c+aM2dOmWPt27dPnTt3liSNGTNGixYtKrNPXl6e4uLi9Omnn0qS7rzzTr3yyivy9fWt9bkDAAB4Un1ca+vUqZO+//57tWjRQidPnpS3t7cOHDig6OjoCutYunSpbr/9dudrpIozmWSN3nbzzTcrJyfH+Z533nmnrrrqKkVEROjUqVP64YcftGbNGi1btkyHDx+WJP33v/9Vnz59atxOAJo+RnID0CyFh4fr0ksvdS4DBw7U8OHD9fDDD2vVqlXavn27+vbtK0n69NNPdeuttzKdAQAAQC2QuwAAAJqGZcuW6ejRo5Kkp556SpL0yy+/aPny5dU+xrnZsFevXrr++uv1xz/+UevWrVOLFi2cx69NJjxy5IiGDh3q7OD2m9/8Rq+++iod3AAAQJPh7mtt/fv3V1RUlEpLS5Wamlrpe7/66quSpBEjRlRZZ3Z2tksHt2nTpmn37t167LHHdPPNN+uKK67Q1VdfrTvuuEMvvPCCsrKyNGPGDPn5+VW3KQA0Q3RyA4By9OjRQ5s2bXKGwE2bNmnBggUergoAAKDpIXcBAAA0Do6pSXv37q1x48apa9euLuvrqkePHrrpppskSUePHtXXX39do9f/9NNPGjx4sD7//HNJ0vjx45WSkiIfHx+31AcAANAY1PRam4+Pj5KSkiSd6cRWnp9//lkrV66UZH2RoCr/8z//4+zgNnv2bM2ePbvSqeNbt26tRx99VGlpaQoJCany+ACaJzq5AUAFAgMD9eqrr8rLy0uS9MQTT6i4uNhln19++UUpKSn69a9/rR49eqhVq1by9/dXZGSk4uLi9Pzzz1f5rdOSkhItWrRIcXFxioyMlL+/v0JCQnTxxRdr6NCheuyxx7Rz5856O08AAABPq+/cdc8998jLy0uBgYHO0Ucq07VrV3l5eenKK690WT927Fh5eXmpU6dOFb522bJlGjlypC644AIFBASodevW6tKli6699lo98sgjzlFFAAAAGpNDhw5pzZo1kqRf//rXLv9duXKlfvrpJ7e8j2MqUkkqKiqq9utycnI0ePBgffnll5KsabxeeOEFeXtzCwQAADQ/1bnWdra7775bkvTll18689S5Xn/9dRUXFys8PFzDhg2r9P23b9+u9957T5LUp08fTZ06tdq1X3vttS6ZEADOxr/wAKASPXv21A033CBJOnjwoLZt2+ayvW/fvrrnnnu0ePFi7dq1S8eOHVNxcbFycnK0atUq/c///I8GDhyo7Ozsco9fWFiowYMHa9y4cVq1apVycnJUXFysgoIC7dmzR2vXrtWf//xnTZ8+vd7PFQAAwJPqM3c5vo168uRJvf3225XW8dlnn+mbb75xeV11lJSU6Pbbb9eoUaP07rvv6scff9SpU6dUWFiorKwsffLJJ5ozZ45+97vfVfuYAAAAdrF48WKVlJTI29tbd911lyQrK3l5eam4uFivv/66W97n+++/dz7u0KFDtV5z8OBBXX/99dqxY4ck6b777tMzzzzjvKkLAADQHFV1re1svXv3Vu/evSVVPJqbY/2dd95Z5VTwKSkpzseTJ09mZF0AbkMnNwCoQmxsrPPxxx9/7LKtpKREAwYM0OzZs7VixQpt27ZNmzZt0muvvab4+HhJ0n//+1+NHj263GM/+uijzmPefPPNev3117Vp0yZlZGToww8/1GOPPaarrrqKi3IAAKBZqK/cNXjwYEVHR0uybtBWJjU1VZI1VUNFGa48Cxcu1NKlSyVJ11xzjRYtWqSPP/5Yn3/+uVavXq1//OMfuuGGG7ioBwAAGiXHTc1Bgwbp/PPPl2SNunbVVVdJcs+UpV9//bVWrFghSRo4cKAiIiKqfM0PP/yg66+/Xrt375YkPfjgg5o/f36dawEAAGgKKrvWdi7HaG6pqakqLS112bZ7925nJznHfpXZsGGD87FjOnoAcIfKu9gCAHT55Zc7HztG9XBYu3atLr744jKvueqqq5SUlKSUlBTdc8892rBhg9LS0jR06FCX/d58801J0m233ea8KXq2+Ph4TZ06VUeOHHHHqQAAANhafeUub29vjR49Wk8++aTWrl2rnJyccm+alpaW6o033pAkDR06tFo3Vh0cuW7AgAFat25dmW+0xsbGasqUKeQ6AADQ6GRmZjqnrXJMUerw61//2vmFzZ07d6pHjx6VHis3N1fbt293PjfGKC8vT+np6Zo3b55OnDihkJAQzZs3r8q6Dhw4oOuvv17fffedJGnatGmaPXt2TU8PAACgyarsWtu5kpKS9Mc//lEHDx5UWlqacxQ46cwXHnr06KF+/fpV+b6O7Hj++efX6PoaAFSFkdwAoApt2rRxPv7ll19ctpV3o/Vs48aNU58+fSRJ77zzTpntjum0rr322kqPExYWVo1KAQAAGrf6zF2OqUdLSkq0ZMmSco+xbt06HTx40GX/6nLkuquuuqrSKRvIdQAAoLFxjNIWGBioxMREl2233367/P39XfarzMKFC9WrVy/n0rt3b1133XV6+OGHlZubq//93//Vp59+qoEDB1Z5rLVr1zo7uD388MN0cAMAADhHZdfazhUVFeX80uhrr73mXG+McT6vzihuBQUFKi4uliSFh4fXuGYAqAyd3ACgCq1atXI+Pnr0aIX7GWOUnZ2tb775Rtu3b3cujikcvvjiizKviYqKkiS98cYbOn78uJsrBwAAaFzqM3ddfvnl6tatm6QzU5Key7E+MDBQt956a41qd+S65cuX6+eff67RawEAAOzq9OnTzoyUkJCg4OBgl+1hYWG68cYbJVnTwp87tVVNlJaWasmSJVq4cKGKioqq3N/Ly8v5eM2aNcrPz6/1ewMAADRF1b3W5uDoxPb2228771t+/PHH+v777+Xt7V2tL4We/T5BQUE1LRkAKkUnNwCowtlh7NwLeZL0/vvv6+abb1ZISIiioqLUtWtXl2+kvv/++5JU7s3OMWPGSJI2b96szp07a9KkSVq2bJl++umnejobAAAA+6rP3CWdGZ3t008/1Z49e1y2FRUV6e2335Yk3XLLLWrdunWNanfkuj179uiiiy7SPffco9dff10//PBDjY4DAABgJx999JFycnIklZ2q1MGx/ocfftC6desqPd6MGTNkjHFZjh8/ri+//FIPPvigCgsLNX/+fMXGxlb5hdBf/epXuv766yVJGRkZuvHGG1VYWFjTUwQAAGiyqrrWdq5Ro0apVatWKiws1LJlyySdGa130KBBat++fZXHOPua2rFjx2paMgBUik5uAFCFs2+Snj29lDFGv/3tb3XzzTfr/fffr/IbECdOnCiz7pFHHtE999wjLy8v5ebmasGCBRo1apTCw8N16aWXasaMGc4LiQAAAE1dfeYuSbrrrrucjxcvXuyy7f3331deXp6kmk9VKkn33HOP/vSnP8nX11f5+flKSUnRXXfdpfbt2+uiiy7S73//e+d0WgAAAI2F46ZmmzZtFB8fX+4+N998s0JDQ132r4nAwED16tVLjz/+uJ555hlJ0ieffKLHHnusytetWLHCObXp5s2bdcstt+jkyZM1rgEAAKApquhaW0VatmypUaNGSZJeffVVnTx5Uv/5z38kVW+qUsnqTOfn5ydJ3OME4HZ0cgOAKvz3v/91Pu7atavz8UsvvaQXX3xRktSnTx8tWrRIu3btUkFBgU6fPu38Nqoj9Bljyhzbz89PL774orZv365p06bpqquukr+/vyRpx44dmjVrli666CK9++679XmKAAAAtlCfuUuSunTpopiYGEllpyx1PK/sBm5V/vKXv2jPnj36y1/+oiFDhqhly5aSpL179+rJJ59Ut27d9Oyzz9bq2AAAAA0tPz9f7733niTp8OHD8vf3l5eXV5mlRYsWzi8LvP3223UasWP8+PHOG7AvvfRSlfu3atVKH374ofr27StJWrdunUaNGqVTp07VugYAAICmoqJrbZVxXF9bs2aNnnvuOeXn56tly5ZKTEys9vv27t1bknTw4EE6ugFwKzq5AUAVVq9e7Xx8zTXXOB+/8MILkqSLLrpImzdv1pgxY9StWze1bt1aPj4+zv2OHDlS5Xv06NFDs2fP1qZNm5Sfn6/Vq1dr3Lhx8vHxUWFhoe68804dOnTIjWcFAABgPw2RuxyjtH3zzTf67LPPJEkFBQXOqU5/9atfOb9tWhsdO3bUn/70J6WlpSkvL0+bNm3SfffdpxYtWqi4uFi/+93vXC4wAgAA2NWbb75Z41HRCgsLnVPA14a3t7cuvvhiSdKhQ4d0+PDhKl8TGhqqVatWqWfPnpKkDz/8UKNHj9bp06drXQcAAEBTUNG1tsoMGTJE559/vkpKSvTHP/5RkjRy5EiXaUir4phSXpLzmhsAuAOd3ACgEtu3b1daWpokqX379urfv79z244dOyRJt9xyiwIDA8t9vTFGn3/+eY3es0WLFoqNjdVLL72kv//975KsKbdWrFhRm1MAAABoFBoqd91+++3y9fWVdGb0trfeest5A7c2U5VWxM/PT1dddZXmz5/vfC9jjHOaBwAAADtzTD0aFRWl119/vcrlggsucHldbZ3dOa26HdXatm2rNWvWODvILVu2TGPGjFFpaWmdagEAAGisKrvWVhlvb2/n9THH9bLqTlXqMHbsWOfjp59+mkwGwG18PV0AANjViRMn9Jvf/MY53dUf/vAH5w1R6cxFtsqmYHj33XfrNALb0KFDnY9//vnnWh8HAADAzhoyd7Vr107Dhg3TBx98oCVLluiJJ55wdkDr2LGjrr766rqcSoXIdQAAoDHJysrSpk2bJEmJiYkaPXp0la/ZsmWL/vnPf2rt2rX68ccfdf7559f4fY8fP66dO3dKkgIDA9W2bdtqvzYyMlJr167Vtddeq3379ik1NVWBgYF64YUX5OXlVeNaAAAAGquqrrVV5e6779Y///lPSVJ4eLhuuOGGGr1/r169dMstt+i9995TZmamHnvsMU2bNq1ar/3kk090/vnnq3PnzjV6TwDNAyO5AUA5du7cqWuuucY5ldT111+viRMnuuzj+Gbo8uXLy50aa+/evUpOTq7wPY4cOaLly5c7A2Z5Vq1a5XxMmAMAAE1RQ+Suczm+jXro0CGlpqZq3bp1kqS77rqr1jdAX3vttUpHGiHXAQCAxuSVV15xXrO67bbbqvUax36lpaV67bXXavW+jz76qE6cOCFJiouLc5mavjouuOACpaWlOTvYvfjii/q///u/WtUCAADQGFXnWltVLr30Up08eVInT57U/v37a5zJJOm5555TRESEJOmRRx7R9OnTderUqQr3P3bsmGbOnKkhQ4YoPz+/xu8HoHlgJDcAzVJubq62b9/ufH7s2DH98ssv+vLLL5WWlqbVq1c7L+QNHDhQ//nPf+Tn5+dyjN/85jd68MEHdfDgQcXExOjhhx92hr61a9dq/vz5Kioq0uWXX17u1FkFBQW65ZZb1KlTJ40aNUoDBgxQx44d5evrq0OHDmn58uX697//LUk6//zzdfPNN9djiwAAANQPO+Suc40YMUJBQUE6duyYJk+erJKSEkl1m6r07rvv1h/+8AeNGjVKV111lS688EK1aNFCOTk5Wr16tRYuXChJatWqlVunRAUAAKgPr776qiRr5I5rr722Wq+56qqrFBUVpUOHDunVV1/Vww8/XGafc7OhZE2D9e233+qVV17RypUrJUktWrTQrFmzalV7ly5dlJaWpuuvv145OTn617/+pZYtW+pvf/tbrY4HAABgJ+641tYQIiMjtWLFCt18883KycnR7Nmz9eqrr+quu+7S1VdfrfDwcJ06dUo//vij1q5dq7feeks//fRTg9cJoHGhkxuAZmnhwoXOG40Vadeune6//3499NBD5Q7he99992n16tVatWqVvvnmG40fP95le2BgoF555RW9//77ld5s3bdvn5588skKt0dFRendd99Vq1atqjgrAAAA+7FT7nIICgrSyJEjtXjxYuXl5UmSLrvsMvXs2bP6J1aOnJycSs83JCRES5YsUfv27ev0PgAAAPVp06ZN2rt3ryTp1ltvlbd39SaE8fb21q233qpnnnlGO3bsUEZGhvr16+eyT3Wz4WuvvaZevXrV7gQkde3aVatXr9agQYN05MgRPf7442rZsqVmzJhR62MCAADYgTuutTWU/v37a+vWrUpOTtb777+vffv26bHHHqtw/6CgID344IPq3r17A1YJoDGhkxuAZs/b21utW7dWSEiIOnbsqH79+unaa6/VzTffLH9//wpf5+fnp/fff18LFy7UK6+8op07d8oYo/PPP1+xsbG677771K1bN73//vvlvr5jx4769NNP9cEHH2jz5s36/vvvlZOTo8LCQoWGhqpHjx5KSEjQhAkTFBwcXF+nDwAA0GA8lbvKk5SUpMWLF7s8r4vt27fr/fff1yeffKK9e/cqJydHeXl5at26tbp166a4uDhNnDjROU0DAACAXb3yyivOx4mJiTV6bWJiop555hnncc7t5FYef39/hYWFqWfPnrrxxhs1btw4nXfeeTUruhy9evXSqlWrNHToUOXn5+vRRx9VUFCQ/vCHP9T52AAAAHZQ22ttDaljx45asWKFtm3bprfeekvr1q3TgQMHdPjwYfn7+ys8PFyXX365hg0bpjvuuIN7ogAq5WUcY1UCAAAAAAAAAAAAAAAAAGAz1RtnHAAAAAAAAAAAAAAAAAAAD6CTGwAAAAAAAAAAAAAAAADAtujkBgAAAAAAAAAAAAAAAACwLTq5AQAAAAAAAAAAAAAAAABsi05uAAAAAAAAAAAAAAAAAADbsk0nt7/+9a/y8vLS/fff71x38uRJJScnq02bNmrVqpUSExOVk5Pj8rr9+/frpptuUsuWLRUeHq4HH3xQp0+fbuDqAQAAAAAAAAAAAAAAAAD1wRad3LZt26bnnntOvXv3dln/wAMPaPny5Vq6dKk2bNiggwcPatSoUc7tJSUluummm3Tq1Clt3rxZL7/8shYtWqTp06c39CkAAAAAAAAAAAAAAAAAAOqBlzHGeLKAwsJCXX755XrmmWc0Z84c9enTR/Pnz1d+fr7atWun1NRU3XbbbZKkr7/+Wt27d1d6eroGDhyoDz/8UDfffLMOHjyoiIgISdKzzz6rhx9+WD/99JP8/f2rVUNpaakOHjyo1q1by8vLq97OFQAAoDzGGB09elTR0dHy9rbFdxBsg5wGAAA8jaxWMbIaAADwJHJaxchpAADA0+ojq/m65Sh1kJycrJtuukmxsbGaM2eOc31GRoaKi4sVGxvrXNetWzd16NDB2cktPT1dvXr1cnZwk6S4uDhNnDhRO3bsUN++fatVw8GDB9W+fXv3nRQAAEAtHDhwQBdccIGny7AVchoAALALslpZZDUAAGAH5LSyyGkAAMAu3JnVPNrJbcmSJfr888+1bdu2Mtuys7Pl7++v0NBQl/URERHKzs527nN2BzfHdse2ihQVFamoqMj53DGY3YEDBxQcHFyrc0E9O3ZMio62Hh88KAUFebYeAADcqKCgQO3bt1fr1q09XYrtONqEnAacg3wMAA2GrFaxWmc1/o4BAAA3IKdVjGtqAGAT/PsXzVh9ZDWPdXI7cOCA7rvvPq1evVotWrRo0PeeO3euZs6cWWZ9cHAwQc+ufHzOPA4O5pc/AKBJYuqAshxtQk4DzkE+BoAGR1Yrq9ZZjb9jAADAjchpZXFNDQBsgn//Am7Nah6boD4jI0O5ubm6/PLL5evrK19fX23YsEFPPfWUfH19FRERoVOnTikvL8/ldTk5OYqMjJQkRUZGKicnp8x2x7aKTJ06Vfn5+c7lwIED7j05AAAAAAAAAAAAAAAAAIBbeKyT29ChQ/XVV18pMzPTufTv319JSUnOx35+fkpLS3O+Zvfu3dq/f79iYmIkSTExMfrqq6+Um5vr3Gf16tUKDg5Wjx49KnzvgIAA5zcX+AYDAAAAAAAAAAAAAAAAANiXx6Yrbd26tS699FKXdUFBQWrTpo1z/fjx4zVlyhSFhYUpODhYkydPVkxMjAYOHChJGjZsmHr06KG7775bjz/+uLKzszVt2jQlJycrICCgwc8JAAAAAAAAAAAAAAAAAOBeHuvkVh3z5s2Tt7e3EhMTVVRUpLi4OD3zzDPO7T4+PlqxYoUmTpyomJgYBQUFacyYMZo1a5YHq0a98PWVfve7M48BAACA5ox8DABozPg7BgAAAABoDvj3L+BWXsYY4+kiPK2goEAhISHKz89n6lIATY4xRiUlJTp9+rSnSwGaJT8/P/n4+FS6D1mkYrQNgKaupKRExcXFni4DaJZ8fX3l4+MjLy+vSvcjj1SMtgHQlJHTAM/imlrd0DYAmjLufQKe5clranQVBYAmyhijvLw8/fTTTyopKfF0OUCzFhoaqsjIyCrDHgCg+TDGKDs7W3l5eZ4uBWjWfHx8FB4erpCQELIaAEASOQ2wE66pAQDOxr1PwD48dU2NTm5oHIyRfv7Zety2rcQ/aIAqOS7GBQcHKzg4WL6+vlwMABqYMUbHjx9Xbm6uJCkqKsrDFQFoMsjHjZ4jq4WHh6tly5bkNKCBGWN0+vRpFRQU6NChQzpx4gRZrSHxdwyAjZHTAM/jmhoAoDyN8t6nMZJjxDlfX/79i0bP09fU6OSGxuH4cSk83HpcWCgFBXm2HsDmSkpKlJ+fr3bt2qlt27aeLgdo1gIDAyVJubm5Cg8Pr3KaBQCoFvJxo1ZSUuK8cdqmTRtPlwM0a61bt1ZAQIB+/vlnslpD4u8YAJsipwH2wTW1/8fe3cdFVSb+/38DAgo6IBqMJBqZqeRdHzKdrTXvAm+iXNl23Uxx19XVD1hGa35ozRRTym3LbBG375paSe2nNitd07z3U+IdRd5QrvrTaIuBymACA7mZ3x/E6Cgo4sDMMK/n43EenTnnmnOuy10973PmOtcFALiQ2/72WVUlHT1as37rrRLXM7QQznqm5t0sZwEANKuKigpZrVYF8kMB4BICAgIk1fzdBACg9npQe30A4FyBgYGyWq1kNQAAOQ1wMTxTAwDU4rdPwPU445kandwAoAVz+SF6AQ/B30UAQF24PgCugb+LAICLcW0AXAN/FwEAF+PaALgOZ/x9pJMbAAAAAAAAAAAAAAAAAMBl0ckNAAAAl8jIyFDfvn1lMBhkMBhkMpn0/vvv2/YPGTJEXl5edsv06dPtjpGXl6cxY8YoICBAoaGhmj17tiorK5u7KQAAAAAAAAAAAADcXCtnVwAAAACup3Pnznr66afVvXt3Wa1WrVmzRvfdd58++eQT3XLLLZKkqVOnKjU11fadgIAA23pVVZXGjBkjo9GoPXv2KD8/X5MmTZKvr68WL17c7O0BAAAAAAAAAAAA4L7o5AYAAIBLxMXF2X1etGiRMjIytHfvXlsnt4CAABmNxjq//8EHHyg3N1dbt25VWFiY+vfvr4ULF2rOnDmaP3++/Pz8mrwNAAAAAAAAAAAAAFoGpiuFe2jVSkpIqFla0TcTABxh9erV8vLy0unTp51dFbi4qqoqvfHGGyotLZXJZLJtX7t2rTp27KjevXsrJSVFZ8+ete3LyspSnz59FBYWZtsWGxsri8Wio0ePNmv9gRaJfAy0aOQ0tHhcxwAAboqcBgAAroqXl9ShQ83i5eXs2rR4ZLWWj05ucA/+/tLq1TWLv7+zawPACY4fr1lq1YaU2qV169a6+eablZSUpIKCAudVtAH27Nmj+fPnq6ioqEHlL25rq1atdP3112vy5Mn66quvmrayV2nz5s3y8vLSa6+9Zre9pKRE99xzj3x8fLRs2TKHn7e8vFxz5sxReHi42rRpo4EDB2rLli2NOtaiRYvk5eWl3r17220vKSnRk08+qZEjRyokJEReXl5avXq1A2rvug4fPqy2bdvK399f06dP17p16xQVFSVJeuCBB/Taa69px44dSklJ0auvvqoHH3zQ9l2z2WzXwU2S7bPZbK73nOXl5bJYLHYLgDqQj+HCyGmOy2mnTl3zIWxack6TpOPHj2v8+PHq3LmzAgIC1LNnT6Wmptp1wocL4ToGAM3u+HHpmWfIaTxPO+9actrRo0d1//3368Ybb1RAQIA6duyowYMHa/369Zf93uXyHAAALZK3txQZWbN4X757Ds/U6s9qF/9O3JzcMavV+vjjj3XvvfcqJCREAQEB6t279yV1deSzu+bAq5IAALeWmpqqyMhIlZWV6cMPP1RGRoY2btyoI0eOKCAgwNnVq9OePXu0YMECTZ48WcHBwQ3+3oVt3bt3r1avXq0PP/xQR44cUevWrZuuwlfh008/lST169fPtu2rr77SPffco+PHj2vdunW69957HX7eyZMn66233tKsWbPUvXt3rV69WqNHj9aOHTt05513Nvg4//nPf7R48WIFBgZesu/bb79VamqqunTpon79+mnnzp0ObIFr6tGjh3JyclRcXKy33npLCQkJ2rVrl6KiojRt2jRbuT59+qhTp04aPny4Tp48qW7dujX6nGlpaVqwYIEjqg8AcDJymnNy2oUP/Lp3P7/eknPal19+qdtvv11BQUFKSkpSSEiIsrKy9OSTTyo7O1vvvvuuI5sEAIDbI6fxPE26tpz2xRdf6IcfflBCQoLCw8N19uxZ/fOf/9S9996rv/3tb3bPjWpdLs8BAIDzyGpkNenan6l9LlwLKgABAABJREFU8MEHiouL06233qonnnhCbdu21cmTJ/Wf//zHoedpbnRyg3uwWqXat68DAhjKE4DNqFGjdNttt0mSfv/736tDhw567rnn9O677+o3v/nNNR27tLTUpR66XNzWjh076plnntF7772nX/3qV06uXY1Dhw7Jz89PPXv2lFQT/MaMGaPq6mrt2rVL0dHRDj/n/v379cYbb+jPf/6z/vjHP0qSJk2apN69e+uxxx7Tnj17GnysP/7xjxo0aJCqqqr07bff2u3r1KmT8vPzZTQadfDgQQ0YMMCh7XBFfn5+uummmyRJ0dHROnDggF544QX97W9/u6TswIEDJUknTpxQt27dZDQatX//frsytW8aGY3Ges+ZkpKi5ORk22eLxaKIiIhrbgvQ4pCP4QbIaeS05sppr776qoqKivThhx/qlltukSRNmzZN1dXVeuWVV/T999+rffv2jmsYrh3XMQBoNnWNeEFOI6dda04bPXq0Ro8ebbctKSlJ0dHReu655+rs5Ha5PAcAQItltUrV1TXr3t4Nuv8lq5HVrjWrWSwWTZo0SWPGjNFbb70l73pGEXTks7vmwnSlcA9nz0pt29YsTDUCeIzaoWevZvjZYcOGSZJO/TS30xdffKH//u//Vo8ePdSmTRt16NBB999//yVzsc+fP19eXl7Kzc3VAw88oPbt29v1Tv/qq6/0u9/9TmFhYfL399ctt9yil19+uc5jnDhxwvamQlBQkH7729/apkmaP3++Zs+eLUmKjIy0DcPbmLnhf/7zn0uSTp48abd98uTJuuGGGy4pX1u/K2lIW+vz6aefqlevXvL19dXGjRt15513qn379tq7d+9Vh7zPP/9ceXl5Vyz31ltvycfHx+7hWevWrTVlyhRlZWXpyy+/bND5du/erbfeektLly6tc7+/v/9lO2d5gurqapWXl9e5LycnR1JNZ0BJMplMOnz4sAoLC21ltmzZIoPBYJvytC7+/v4yGAx2C4A6kI/hhshp5DSpaXJa7fTmF0+V3qlTJ3l7e8vPz69B50Ez4joGAC6FnEZOkxqX0y7k4+OjiIiIOqcpu1KeAwCgxaqulj75pGap7ex2lchq0pw5kzV06A2XlCer1S0zM1MFBQVatGiRvL29VVpaquo6/v/XFJmwqTGSGwCgRakNPR06dJAkHThwQHv27NH48ePVuXNnnT59WhkZGRoyZIhyc3MvGdb3/vvvV/fu3bV48WJZrVZJNaNPDRo0SF5eXkpKStJ1112n999/X1OmTJHFYtGsWbPsjvGrX/1KkZGRSktL08cff6y///3vCg0N1TPPPKNx48bp3//+t15//XU9//zz6tixoyTpuuuuu+q21oZDR45KcbVtvdC5c+d07Ngx/eY3v9Hy5cv10EMPadiwYXrrrbca1VGpV69euuuuu644Legnn3yim2+++ZJz3H777ZJqOl9daSSwqqoqzZw5U7///e/Vp0+fq65rS5SSkqJRo0apS5cu+uGHH5SZmamdO3dq8+bNOnnypDIzMzV69Gh16NBBhw4d0iOPPKLBgwerb9++kqSYmBhFRUVp4sSJWrJkicxms+bOnavExET5+/s7uXUAAGcgp12bC9v6m98kKSTkOmVnk9MkaciQIXrmmWc0ZcoULViwQB06dNCePXuUkZGhhx56yKXeUAYAwBWR066Npz5Pk2pGg/nxxx9VXFys9957T++//75+/etf25XhuRsAANeGrHZllxswxROz2tatW2UwGPTVV19p7Nix+ve//63AwEBNnDhRzz//vG0qWEdlwuZEJzcA8ESlpfXv8/GRLpzj/HJlvb2lNm0aV9ZBiouL9e2336qsrEwfffSRUlNT1aZNG91zzz2SpDFjxuiXv/yl3Xfi4uJkMpn0z3/+UxMnTrTb169fP2VmZtpt+9Of/qSqqiodPnzYFiCnT5+u3/zmN5o/f77+8Ic/qM0Fbbv11lu1cuVK2+fvvvtOK1eu1DPPPKO+ffvqv/7rv/T6669r7Nixdb4h2pC27tu3TwsWLJC/v7+trY5wtW29UG5urioqKrRjxw698sor+v3vf6+MjAy1atW0cSM/P982etiFard9/fXXVzzGihUr9MUXX2jr1q0Or5+7Kiws1KRJk5Sfn6+goCD17dtXmzdv1t13360vv/xSW7du1dKlS1VaWqqIiAjFx8dr7ty5tu/7+Phow4YNmjFjhkwmkwIDA5WQkKDU1FQntgoA3IAr5LSzZ2umD7xG5LSmy2lnztS0dd48cpokjRw5UgsXLtTixYv13nvv2bb/6U9/0lNPPdWImgMAUA9XyGoOQE7jeZojcpokPfroo/rb3/4mSfL29ta4ceP017/+1a4Mz90AAM2iheQ0iaxGVrv2rHb8+HFVVlbqvvvu05QpU5SWlqadO3fqxRdfVFFRkV5//XWHnMcZ6OQGAJ6obdv6940eLf3rX+c/h4bWP33MXXdJF/Y0v+EG6dtv6y57223SgQNXW9MrGjFihN3nrl27au3atbr++uslyS6UVFRUyGKx6KabblJwcLA+/vjjS4Le9OnT7T5brVb985//1K9+9StZrVZ9e0H7YmNj9cYbb+jjjz/WHXfcUe8xfv7zn2vdunWyWCzXNPXixW294YYb9Nprr6lz586NPuaFGtPWCx06dEiSVFRUpDZt2uiJJ564ppBX+zbJlfz44491jgxW+xbCjz/+eNnvf/fdd5o3b56eeOKJRr1V0lJdeLNysYiICO3ateuKx+jatas2btzoyGoBQMvnCjktKkpqxHQCFyOnNV1OO3Ompq3ffktOq3XDDTdo8ODBio+PV4cOHfSvf/1LixcvltFoVFJSUoPqCwDAFblCVnMAchrP0641p9WaNWuWfvnLX+rrr7/W//7v/6qqqkrnzp2z7ee5GwCg2bSQnCaR1chq157VSkpKdPbsWU2fPl3Lli2TJI0bN07nzp3T3/72N6Wmpqp79+4Oy4TNiU5uAAC3cvFws+np6br55pvVqlUrhYWFqUePHvL29rbt//HHH5WWlqZVq1bpq6++sgsPxcXFlxw/MjLS7vM333yjoqIivfTSS3rppZfqrFNhYaHd5y5duth9rh1S9/vvv7+moFfb1uLiYr388svavXu3Q6d9bExbL/Tpp59Kkt59913dc889+uUvf6kPP/xQfn5+DqtjXdq0aaPy8vJLtpeVldn2X87cuXMVEhKimTNnNkn9AADwVOQ0clpz5bQ33nhD06ZN07///W/bQ9Bx48apurpac+bM0W9+8xvbm7oAAICcRk679pxWq2fPnurZs6ckadKkSYqJiVFcXJz27dsnLy8vnrsBANAIZDWy2rVmtdr9v/nNb+y2P/DAA/rb3/6mrKwsde/e3WGZsDnRyQ0APFFJSf37fHzsP1/mwq4LApWky4/4cXFZB7n99tt122231bt/5syZWrVqlWbNmiWTyaSgoCB5eXlp/Pjxqq6uvqT8xRfr2jIPPvigEhIS6jxH37597T77XPxn+JOG9s6vz4VtHTt2rO6880498MADOnbsmNpe8IaKl5dXnd+vqqq67PEb09YLHTp0SEajUUOHDlVGRoYSEhL08MMPKyMj47LnvVadOnXSV199dcn2/Px8SVJ4eHi93z1+/LheeuklLV261G7I3bKyMlVUVOj06dMyGAwKCQlxfMUBAKiLK+S03Nz6y14FclrDc9o331xdTvvPf2q2X/hSa105rfYFkZae05YvX65bb731krd87733Xq1evVqffPLJJW8GAwDQKK6Q1Rzg9ttvV1BQTXbp3v3S/eS083iednV++ctf6g9/+IP+/e9/y9vbm+duAIDm00JymsQzNbLatWe18PBwHT16VGFhYXbbQ0NDJdV0TnTEeZyBTm4A4IkCA51ftpm89dZbSkhI0F/+8hfbtrKyMhUVFTXo+9ddd53atWunqqoqh/0wVl8Quxo+Pj5KS0vT0KFD9de//lX/8z//Y9vXvn37Otv3xRdfXPaY19rWQ4cOqX///pJq3tz88MMPtWLFCv3sZz+7ZGjk6upqLV26VCtWrNC3336r++67Ty+99JJ8fX2v+rz9+/fXjh07LhkSed++fbb99fnqq69UXV2thx56SA899NAl+yMjI/Xwww9r6dKlV10vAAAaxRVyWkBAw8teA3LaeV99dXU5rbbzWl0/Stelpee0goIC2xvEF6qoqJAkVVZWXnXdAQCokytkNQfIy5P69Kl/PzntPJ6nXZ3aKa2Ki4t19uxZnrsBAJpPC8lpDdGSslpenhQUVPOM63JZzWBoL4ul6JLvk9XqFh0drS1btuirr75Sjx49bNtrXzyonUa+qTJhU2qarqWAo/n4SL/8Zc1STy9hAKiLj4/PJW8RvPjii1fs2X/h9+Pj4/XPf/5TR44cuWT/N998c9V1CvwpEDc0bNZnyJAhuv3227V06VLbsLGS1K1bNxUXF9vmiZdqetyvW7fusse7lraazWYVFhbave2wbNky3XrrrZo+fboOHz5sV37evHnasGGDdu7cqS+++EKnTp3Syy+/bFfm888/V15e3mXrLNW8IVpVVWU3zHB5eblWrVqlgQMHKiIiQpJ09uxZff755/r2229t5Xr37q1169Zdstxyyy3q0qWL1q1bpylTplyxDgDQ7MjHaAHIaTXy8/O1dWvT5bRvvmn5Oe3mm2/WJ598on//+99253/99dfl7e192Tdy4SRcxwCgyRw/fn4018Z+38uLnCbxPE2qO6dJdU/rVVFRoVdeeUVt2rRRVFQUz90AAJAkLy+pffuaxQGd9iXPfKbWpUs3/fADWa2hWe1Xv/qVJGnlypV22//+97+rVatWGjJkyFWdx5UwkhvcQ+vW0ptvOrsWANzQPffco1dffVVBQUGKiopSVlaWtm7dqg4dOjT4GE8//bR27NihgQMHaurUqYqKitKZM2f08ccfa+vWrTpz5sxV1Sk6OlqS9Kc//Unjx4+Xr6+v4uLibAHwasyePVv333+/Vq9erenTp0uSxo8frzlz5ugXv/iFHnroIZ09e1YZGRm6+eab9fHHHzdJW2vnpL8w6LVu3VpvvfWWoqOjFR8fr4MHD8pgMCg/P18vvPCCjh8/LqPRaKtzdna23TF79eqlu+66Szt37rxsnQcOHKj7779fKSkpKiws1E033aQ1a9bo9OnTduFt//79Gjp0qJ588knNnz9fktSxY0eNHTv2kmPWvkF68b6//vWvKioqsr3psH79ev3np/nCZs6cqaCgoMvWFQAchnyMFoCcdj6n3XDDzTp6tOE57f77p6pbtyj5+l65rZ9/3vJz2uzZs/X+++/r5z//uZKSktShQwdt2LBB77//vn7/+9+75NQKHo/rGAC4tCFDyGk8T6tRV06TpD/84Q+yWCwaPHiwrr/+epnNZq1du1aff/65/vKXv6ht27Zq27btVT13AwCgRfL2lrp1c+ghPfGZ2pgx4/Xss1fOagUFjmurO2e1W2+9Vb/73e/08ssvq7Ky0nbON998UykpKbZnZQ09jyuhkxsAoEV74YUX5OPjo7Vr16qsrEx33HGHtm7dqtjY2AYfIywsTPv371dqaqrefvttLV++XB06dNAtt9yiZ5555qrrNGDAAC1cuFArVqzQpk2bVF1drVOnTjUq6I0bN07dunXTs88+q6lTp8rHx0cdOnTQunXrlJycrMcee0yRkZFKS0vT8ePHr/hQrrFtrX1z4uJRMm688UatXr1av/jFL5SQkKB169Zp69atKisrU8+ePW3lqqqqbEG1MV555RU98cQTevXVV/X999+rb9++2rBhgwYPHtzoY9bl2WeftRv6+O2339bbb78tSXrwwQfp5AYAwFUgp53PaXv3Hr9iJ7eL2/rttw1r67FjLT+nDR48WHv27NH8+fO1fPlyfffdd4qMjNSiRYv02GOPOew8AAB4irlzX1D79uQ0nqfV79e//rVWrlypjIwMfffdd2rXrp2io6P1zDPP6N577210nQAAwJV54jO19u07KD19nf7yF7JaQ5+prVixQl26dNGqVau0bt06de3aVc8//7xmzZrl0PM0Ny/rxeMYeiCLxaKgoCAVFxfbzTOLS3l5eWndunW8YQO4uLKyMp06dUqRkZFq3bq1s6vTaJebWqF79+arBxzrhRde0OHDh/X3v//d2VVpNlf6O0kWqR9/Ng1HTgPcR0vJanCc2tx7Ycata9vV7LtQQ7OzJ+Y0iax2LfizaTiyGuAeWkJOuzgnXGnq0vrK8ezNtZDTyGlXiz+bhiOnAe6hJeQ02Lswf14pezbVszBHIas1X1bzdshR0Oy8vLwuu1w4FOHFTp8+LS8vL+Xk5DRJ3cxms2bOnKkbb7xR/v7+ioiIUFxcnLZt29b4g5aW1sxR7eVVs95AXl5eeuedd676dPn5+XrggQd08803y9vb+5LerLXefPNN9ezZU61bt1afPn20ceNGu/1Wq1Xz5s1Tp06d1KZNG40YMULHL/pX9syZM5owYYIMBoOCg4M1ZcoUlZSU2JU5dOiQfv7zn6t169aKiIjQkiVLrrpNgDs5fvzKD+Dgvvr3769Nmzbp888/lyR999132rx5s5NrBTiOx+W0RiKnXaNG5mMAuBxyGpqNE69jZLWGIasBgGshp8ETkNMahpwGuJmqKungwZqlqsrZtUETIas1Hzq5uan8/HzbsnTpUts8v7XLH//4R6fU6/Tp04qOjtb27dv15z//WYcPH9amTZs0dOhQJSYmOqVOjVFeXq7rrrtOc+fOVb9+/eoss2fPHv3mN7/RlClT9Mknn2js2LEaO3asjhw5YiuzZMkSLVu2TCtWrNC+ffsUGBio2NhYlZWV2cpMmDBBR48e1ZYtW7Rhwwbt3r1b06ZNs+23WCyKiYlR165dlZ2drT//+c+aP3++Xnrppab7AwCAJnTXXXdp5syZuvvuu9W2bVvdfvvtdv92Au6OnNa0yGkA0HTIae4jIyNDffv2lcFgkMFgkMlk0vvvv2/bX1ZWpsTERHXo0EFt27ZVfHy8CgoK7I6Rl5enMWPGKCAgQKGhoZo9e7YqKyubuynNjqzWtMhqANA0yGnwBOS0pkVOA4CmQ1ZrRlZYi4uLrZKsxcXFzq5Ko6xatcoaFBRk+1xVVWVdsGCB9frrr7f6+flZ+/XrZ33//fdt+yXZLXfddZfVarVa9+/fbx0xYoS1Q4cOVoPBYB08eLA1Ozvb7lySrOvWrau3LqNGjbJef/311pKSkkv2ff/997b1L774wnrvvfdaAwMDre3atbPef//9VrPZbNufkJBgve+++85/uaTE+rBkvUuyWn869l133WWdOXOmdfbs2db27dtbw8LCrE8++aTtK127drVrZ9euXeut9+Xcdddd1ocffviS7b/61a+sY8aMsds2cOBA6x/+8Aer1Wq1VldXW41Go/XPf/6zbX9RUZHV39/f+vrrr1utVqs1NzfXKsl64MABW5n333/f6uXlZf3qq6+sVqvVunz5cmv79u2t5eXltjJz5syx9ujRo1HtgWf48ccfrbm5udYff/zR2VVplH//+8oL4E6u9HfS3bNIU3L3PxuPyGlWq/Xhhx+21dVqJac1S04rKbFapZqljv9N4drcPavB8erKuJfLvQ3ZR3ZuOHfMau+99571X//6l/Xf//639dixY9bHH3/c6uvraz1y5IjVarVap0+fbo2IiLBu27bNevDgQeugQYOsP/vZz2zfr6ystPbu3ds6YsQI6yeffGLduHGjtWPHjtaUlJSrqkej/2xc5DpGViOrARdrCTnt4ut/Q5+xkR/gitwxp7kKd/+zIaeR04CLuW1Oq6y0Wg8cqFkqK51dG5dyNdmTZ2GuyRlZjZHcWqAXXnhBf/nLX/Tss8/q0KFDio2N1b333msbKnb//v2SpK1btyo/P19vv/22JOmHH35QQkKCPvzwQ+3du1fdu3fX6NGj9cMPPzTovGfOnNGmTZuUmJiowMDAS/YHBwdLkqqrq3XffffpzJkz2rVrl7Zs2aL/7//7//TrX//6qtu6Zs0aBQYGat++fVqyZIlSU1O1ZcsWSdKBAwckSatWrVJ+fr7tc+2QxTt37rzq810oKytLI0aMsNsWGxurrKwsSdKpU6dkNpvtygQFBWngwIG2MllZWQoODtZtt91mKzNixAh5e3tr3759tjKDBw+Wn5+f3XmOHTum77///praAAAAmhc5jZwGAIAjxMXFafTo0erevbtuvvlmLVq0SG3bttXevXtVXFyslStX6rnnntOwYcMUHR2tVatWac+ePdq7d68k6YMPPlBubq5ee+019e/fX6NGjdLChQuVnp6uc+fOObl1zkNWI6sBAADXRE4jpwEAIEmtnF0BON6zzz6rOXPmaPz48ZKkZ555Rjt27NDSpUuVnp6u6667TpLUoUMHGY1G2/eGDRtmd5yXXnpJwcHB2rVrl+65554rnvfEiROyWq3q2bPnZctt27ZNhw8f1qlTpxQRESFJeuWVV3TLLbfowIEDGjBgQIPb2rdvXz355JOSpO7du+uvf/2rtm3bprvvvtvWzuDgYLt2+vr6qkePHgoICGjweepiNpsVFhZmty0sLExms9m2v3bb5cqEhoba7W/VqpVCQkLsykRGRl5yjNp97du3v6Z2AACA5kNOI6cBAOBoVVVVevPNN1VaWiqTyaTs7GxVVFTY/fDUs2dPdenSRVlZWRo0aJCysrLUp08fu2thbGysZsyYoaNHj+rWW2+t81zl5eUqLy+3fbZYLE3XMCcgq5HVAACAayKnkdMAAJAkRnJrYSwWi77++mvdcccddtvvuOMOffbZZ5f9bkFBgaZOnaru3bsrKChIBoNBJSUlysvLa9C5rVZrg8p99tlnioiIsIU8SYqKilJwcPAV63ixvn372n3u1KmTCgsLL/ud66+/Xp9//rluv/32qzoXAADAtSCnkdMAAHCkw4cPq23btvL399f06dO1bt06RUVFyWw2y8/PzzaqRK2Lf3iq64ep2n31SUtLU1BQkG25MDO4O7IaWQ0AAEfIyMhQ3759ZTAYZDAYZDKZ9P7779v2l5WVKTExUR06dFDbtm0VHx+vgoICu2Pk5eVpzJgxCggIUGhoqGbPnq3KysrmborLIKeR0wC0LMeP1yxAY9DJDTYJCQnKycnRCy+8oD179ignJ0cdOnRo8DQV3bt3l5eXlz7//PNrrou3t/clwbGijnK+vr52n728vFRdXX3N528Io9F4yY1HQUGB7c2J2v9eqczFwbSyslJnzpyxK1PXMS48BwAAaNlcPqdVXJrUyGnkNABA0+rRo4dycnK0b98+zZgxQwkJCcrNzW3Sc6akpKi4uNi2fPnll016PndBVrs6ZDUAQEvWuXNnPf3008rOztbBgwc1bNgw3XfffTp69Kgk6ZFHHtH69ev15ptvateuXfr66681btw42/erqqo0ZswYnTt3Tnv27NGaNWu0evVqzZs3z1lNcmvktKtDTgPQktV2rqODnXujk1sLYzAYFB4ero8++shu+0cffaSoqChJss1vXlVVdUmZhx56SKNHj9Ytt9wif39/ffvttw0+d0hIiGJjY5Wenq7S0tJL9hcVFUmSevXqpS+//NLuQWhubq6KiopsdbzuuuuUn59//ss+Pspp314KCZF8fBpcJ19f30va6Sgmk0nbtm2z27ZlyxaZTCZJUmRkpIxGo10Zi8Wiffv22cqYTCYVFRUpOzvbVmb79u2qrq7WwIEDbWV2795tF3S3bNmiHj16MFwvrqihbxm1FIQTuCpP+7uIurXYnCYpJyenwXWpRU67Rj4+0ujRNctV5GO4Fq4PgGtw17+Lfn5+uummmxQdHa20tDT169dPL7zwgoxGo86dO2e7vte6+Ienxvyo5O/vbxuVpHZpFBe8jpHV7JHV4Onc9doAtDTu+HcxLi5Oo0ePVvfu3XXzzTdr0aJFatu2rfbu3avi4mKtXLlSzz33nIYNG6bo6GitWrVKe/bs0d69eyVJH3zwgXJzc/Xaa6+pf//+GjVqlBYuXKj09PQGd8xqachp9shp8HRud23w8pKCgmoWLy9n1wZwKGf8faSTWws0e/ZsPfPMM/rHP/6hY8eO6X/+53+Uk5Ojhx9+WJIUGhqqNm3aaNOmTSooKFBxcbGkmrcRXn31VX322Wfat2+fJkyYoDZt2lzVudPT01VVVaXbb79d//znP3X8+HF99tlnWrZsmS3cjBgxQn369NGECRP08ccfa//+/Zo0aZLuuusu3XbbbZKkYcOG6eDBg3rllVd0/PhxPZmWpiNVVVKfPlLr1g2uzw033KBt27bJbDbr+++/lyR99dVX6tmzp/bv33/Z7+bk5CgnJ0clJSX65ptvlJOTY/dG9MMPP6xNmzbpL3/5iz7//HPNnz9fBw8eVFJSkqSaNytmzZqlp556Su+9954OHz6sSZMmKTw8XGPHjpVUE3pHjhypqVOnav/+/froo4+UlJSk8ePHKzw8XJL0wAMPyM/PT1OmTNHRo0f1j3/8Qy+88IKSk5Mb/OcAz+Pr6ysvL686b7oANL+zZ89KuvQtPHieFpnTnnxSR44cueo/C3LaNWrdWvrXv2qWq8jHcA2114Pa6wMA5yotLZWXl5fbZ7Xq6mqVl5crOjpavr6+dj88HTt2THl5eXY/PB0+fNhuhIUtW7bIYDDYfoRrUi56HSOrnUdWg6fyxJzGC6NwZe7+TK2qqkpvvPGGSktLZTKZlJ2drYqKCo0YMcJWpmfPnurSpYuysrIkSVlZWerTp4/d1PKxsbGyWCy20eA8ETntPHIaPJXb/vbp7S11716zeNM9By2LM56ptWq2M6HZPPTQQyouLtajjz6qwsJCRUVF6b333lP37t0lSa1atdKyZcuUmpqqefPm6ec//7l27typlStXatq0afqv//ovRUREaPHixfrjH/94Vee+8cYb9fHHH2vRokV69NFHlZ+fr+uuu07R0dHKyMiQVBOA3n33Xc2cOVODBw+Wt7e3Ro4cqRdffNF2nNjYWD3xxBN67LHHVFZWpt/97neaNGmSDh8+fFX1+ctf/qLk5GT9v//3/3T99dfr9OnTqqio0LFjx674oOLWW2+1rWdnZyszM1Ndu3bV6dOnJUk/+9nPlJmZqblz5+rxxx9X9+7d9c4776h379627z322GMqLS3VtGnTVFRUpDvvvFObNm1S6wse4K5du1ZJSUkaPny4vL29FR8fr2XLltn2BwUF6YMPPlBiYqKio6PVsWNHzZs3T9OmTbuqPwt4Fh8fHwUFBembb75ReXm5DAaDWrVqJS83eUOgIS8hlZVd/nt17Qeam9Vq1dmzZ1VYWKjg4GD5uMgoFXAectp55DR4Mh8fHwUHB9s6lwQEBLhNTkPTqM2xF2bYurZdzb4LkY0vZbVaVVlZKYvFIovF4nZZLSUlRaNGjVKXLl30ww8/KDMzUzt37tTmzZsVFBSkKVOmKDk5WSEhITIYDJo5c6ZMJpMGDRokSYqJiVFUVJQmTpyoJUuWyGw2a+7cuUpMTJS/v7+TW+c8ZLXzyGrwVC0hp12cExo72A/5Ac7k7s/UDh8+LJPJpLKyMrVt21br1q1TVFSUcnJy5Ofnp+DgYLvyYWFhMpvNkiSz2WzXwa12f+2++pSXl6u8vNz22WKxOKg1roGcdh45DZ7K3X/7xHlXenb10z9JuuGGS79zLc/C+B3ZMZz9TM3L6nbjOTqexWJRUFCQiouLGz/NAgC4GKvVquLiYhUWFjbZ0NVN5YLBBOoVGnr579W1H3CW4OBgGY3Gem+2yCL1488GQEtltVplNpsvmU4Qnqk2x16YYS+3rdaVMvHlyqGGj4+PQkNDFRQU5FZZbcqUKdq2bZvy8/MVFBSkvn37as6cObr77rslSWVlZXr00Uf1+uuvq7y8XLGxsVq+fLndVKRffPGFZsyYoZ07dyowMFAJCQl6+umn1apVw9+JdcU/GwC4Vu6e0y7OEA15zlYX8gNcgbs+Uzt37pzy8vJUXFyst956S3//+9+1a9cu5eTk6Le//a1dZzRJuv322zV06FA988wzmjZtmr744gtt3rzZtv/s2bMKDAzUxo0bNWrUqDrPOX/+fC1YsOCS7a72ZwMA18Kdf/v0dFfKpA19JnYtz8L4HdmxnPVMjU5uct0QjAuUltrflQcGOrc+gBuxWq2qqqpSZWWls6vSYDNmXLnMTy9I1fu9uvYDzuDr63vFNxjIIvXjzwaoB/m4xaiqqlJFRYWzqwEnq82xF2bYy22rdbl99ZXDea1atZKPj88V3/omj9Sv0X82XMcAuAF3zWkXZ4iGPGerC/kBztaSnqmNGDFC3bp1069//WsNHz5c33//vd1obl27dtWsWbP0yCOPaN68eXrvvfeUk5Nj23/q1CnbaGIXjsR1obpGcouIiHD5PxsAaAy3+u3z7Fnpjjtq1j/6SAoIcG59nORKmbShz8Su9PtwXcerqxxZ99o485ka05XCfVxhiF0AdfPy8lKrVq2u6m18Z/v22yuXuWDk6zq/d//9Nf9dv94xdQIAwOWQj1sEHx8ft5t6B45Xm2MvzLiX21brcvvqKwe4DK5jAFycu+a0izNEQ56z1YX8ADhOdXW1ysvLFR0dLV9fX23btk3x8fGSpGPHjikvL08mk0mSZDKZtGjRIhUWFir0p5cCtmzZIoPBoKioqHrP4e/v79HTzgPwLG7122dVlfT55zXr/v4eG7KulEkb+kzsSr8P13W8usp56P8MLYK3M0+ekZGhvn37ymAwyGAwyGQy6f3337ftHzJkiLy8vOyW6dOn2x0jLy9PY8aMUUBAgEJDQzV79mz36LELAAAAAAAAAAAAoMVISUnR7t27dfr0aR0+fFgpKSnauXOnJkyYoKCgIE2ZMkXJycnasWOHsrOz9dvf/lYmk0mDBg2SJMXExCgqKkoTJ07Up59+qs2bN2vu3LlKTEykExsAAPB4Tu3a2rlzZz399NPq3r27rFar1qxZo/vuu0+ffPKJbrnlFknS1KlTlZqaavtOwAXDN1ZVVWnMmDEyGo3as2eP8vPzNWnSJPn6+mrx4sXN3h4AAAAAAAAAAAAAnqmwsFCTJk1Sfn6+goKC1LdvX23evFl33323JOn555+Xt7e34uPjVV5ertjYWC1fvtz2fR8fH23YsEEzZsyQyWRSYGCgEhIS7H4rBQAA8FRO7eQWFxdn93nRokXKyMjQ3r17bZ3cAgICZDQa6/z+Bx98oNzcXG3dulVhYWHq37+/Fi5cqDlz5mj+/Pny8/Nr8jYAAAAAAAA0lYsenQAAAABwYStXrrzs/tatWys9PV3p6en1lunatas2btzo6KoBAAC4PadOV3qhqqoqvfHGGyotLbXNOy9Ja9euVceOHdW7d2+lpKTo7Nmztn1ZWVnq06ePwsLCbNtiY2NlsVh09OjRes9VXl4ui8VitwAAAAAAAAAAAKCmo/2FCwAAAAA4m1NHcpOkw4cPy2QyqaysTG3bttW6desUFRUlSXrggQfUtWtXhYeH69ChQ5ozZ46OHTumt99+W5JkNpvtOrhJsn02m831njMtLU0LFixoohYBAAAAAAAAAAAAAAAAABzF6Z3cevTooZycHBUXF+utt95SQkKCdu3apaioKE2bNs1Wrk+fPurUqZOGDx+ukydPqlu3bo0+Z0pKipKTk22fLRaLIiIirqkdaGLe3tJdd51fBwAAADwZ+RgA4M64jgGAwzHaGgAAgAvi/hdwKKd3cvPz89NNN90kSYqOjtaBAwf0wgsv6G9/+9slZQcOHChJOnHihLp16yaj0aj9+/fblSkoKJAkGY3Ges/p7+8vf39/RzUBzaFNG2nnTmfXAgAAAHAN5GMA4sdsuDGuYwAAAAAAT8D9L+BQTu/kdrHq6mqVl5fXuS8nJ0eS1KlTJ0mSyWTSokWLVFhYqNDQUEnSli1bZDAYbFOeAgAAAAAAAAAAAAAAAHAPvNyJuji1k1tKSopGjRqlLl266IcfflBmZqZ27typzZs36+TJk8rMzNTo0aPVoUMHHTp0SI888ogGDx6svn37SpJiYmIUFRWliRMnasmSJTKbzZo7d64SExMZqQ0AAAAAAAAAAAAAAAAAWgCnTvpbWFioSZMmqUePHho+fLgOHDigzZs36+6775afn5+2bt2qmJgY9ezZU48++qji4+O1fv162/d9fHy0YcMG+fj4yGQy6cEHH9SkSZOUmprqxFahSZSWStddV7OUljq7NgAAAIBzkY8BAO6M6xgAAAAAwBNw/ws4lFNHclu5cmW9+yIiIrRr164rHqNr167auHGjI6sFV/Xtt86uAQAAAOA6yMeA22PaBXg0rmMAAAAAAE/gwfe/Tfnsi+dqnsmpI7kBAAAAAAAAAAAAAAAAAHA5dHIDAAAAAAAAAAAAAAAAALgsOrkBAAAAAAAAAAAAAAAAAFwWndwAAAAAAAAAAAAAAAAAAC6rlbMrAAAAAAAAAAAAAAAAAADXKi7u/Pr69c6rBxyPTm5wD97e0m23nV8HAAAAPBn5GADgzriOAQAAAAA8Afe/DXJhpzTgcujkBvfQpo104ICzawEAAAC4BvIxAMCdcR0DAAAAAHgC7n8Bh6KrKAAAAAAAAAAAAAAAAADAZdHJDQAAAAAAAAAAAAAAAADgsujkBvdw9qx0ww01y9mzzq4NAAAA4FzkYwCAO+M6BgAAAADwBNz/Ag5FJze4B6tV+uKLmsVqdXZtAABo8TIyMtS3b18ZDAYZDAaZTCa9//77tv1lZWVKTExUhw4d1LZtW8XHx6ugoMDuGHl5eRozZowCAgIUGhqq2bNnq7KysrmbArRM5GMAgDvjOgYAAAAA8ATc/zpUXNz5BZ6plbMrAAAAANfTuXNnPf300+revbusVqvWrFmj++67T5988oluueUWPfLII/rXv/6lN998U0FBQUpKStK4ceP00UcfSZKqqqo0ZswYGY1G7dmzR/n5+Zo0aZJ8fX21ePFiJ7cOAADXxAM6AAAAAAAAAKgbndwAAABwibiLfmVftGiRMjIytHfvXnXu3FkrV65UZmamhg0bJklatWqVevXqpb1792rQoEH64IMPlJubq61btyosLEz9+/fXwoULNWfOHM2fP19+fn7OaBYAAAAAAAAAAAA8BC+VtixMVwoAaHYMJQu4l6qqKr3xxhsqLS2VyWRSdna2KioqNGLECFuZnj17qkuXLsrKypIkZWVlqU+fPgoLC7OViY2NlcVi0dGjR5u9DQAAAAAAAAAAAADcFyO5AQAAoE6HDx+WyWRSWVmZ2rZtq3Xr1ikqKko5OTny8/NTcHCwXfmwsDCZzWZJktlstuvgVru/dl99ysvLVV5ebvtssVgc1BoAAAAAAFoeXiIFAAAA4CkYyQ0AAAB16tGjh3JycrRv3z7NmDFDCQkJys3NbdJzpqWlKSgoyLZEREQ06fkAAAAAAAAAAABwbZjFC82BkdzgHry8pKio8+sAAKDJ+fn56aabbpIkRUdH68CBA3rhhRf061//WufOnVNRUZHdaG4FBQUyGo2SJKPRqP3799sdr6CgwLavPikpKUpOTrZ9tlgsdHQD6kI+BgC4M65jANDk+IERAADABXjg/S85FE2JTm5wDwEB0tGjzq4FAAAerbq6WuXl5YqOjpavr6+2bdum+Ph4SdKxY8eUl5cnk8kkSTKZTFq0aJEKCwsVGhoqSdqyZYsMBoOiam/o6uDv7y9/f/+mbwzg7sjHAAB3xnUMAAAAAOAJuP8FHIpObgAAALhESkqKRo0apS5duuiHH35QZmamdu7cqc2bNysoKEhTpkxRcnKyQkJCZDAYNHPmTJlMJg0aNEiSFBMTo6ioKE2cOFFLliyR2WzW3LlzlZiYSCc2AAAAAADcWO3oHOvXO7ceAAAAADwLndwAAE7liIdiDHsLOF5hYaEmTZqk/Px8BQUFqW/fvtq8ebPuvvtuSdLzzz8vb29vxcfHq7y8XLGxsVq+fLnt+z4+PtqwYYNmzJghk8mkwMBAJSQkKDU11VlNAgAAAAAAAAAAgIPwGy2aG53c4B7OnpUGDKhZP3CgZlhPAADQZFauXHnZ/a1bt1Z6errS09PrLdO1a1dt3LjR0VUDIJGPAVwVRluBy+E6BgAAAADwBNz/Ag5FJze4B6tVys09vw4AAAB4MvIxAMCdcR0DAAAAAHgC7n8Bh6KTGwAAAAAAAAAAAC6L6agAAADQEjDrgfvydnYFAAAAAAAAAAAA4Lro4AYAAADA2ejkBgAAAAAAAAAAAAAAAABwWUxXCgAAAAAA4AEuHIGF6RgAAAAAAAAAuBNGcgMAAAAAAAAAAAAAAAAAuCxGcoN78PKSunY9vw7A4104CsW1fJcRLAAAbol8DABwZ1zHAAAAAACegPtfwKHo5Ab3EBAgnT7t7FoAAAAAroF8DABwZ1zHAAAAAACegPtfwKHo5AYAAAAAAAAAAOBGrmWWAwAAAABwR97OrgAAAAAAAAAAAAAAAAAAAPWhkxvcw48/SgMG1Cw//ujs2gAAAADORT4GALgzrmMAAAAAAE/A/S/gUExXCvdQXS0dPHh+HQAAAPBk5GMAgDvjOgYAAAAA8ATc/wIORSc3AAAAAAAAAAAAAAAAAB4jLu78+vr1zqsHGo7pSgEALVpc3PkFAAAAQA0ysntLS0vTgAED1K5dO4WGhmrs2LE6duyYXZkhQ4bIy8vLbpk+fbpdmby8PI0ZM0YBAQEKDQ3V7NmzVVlZ2ZxNAQAAAAAAABqEkdwAAAAAAAAAN7Jr1y4lJiZqwIABqqys1OOPP66YmBjl5uYqMDDQVm7q1KlKTU21fQ4ICLCtV1VVacyYMTIajdqzZ4/y8/M1adIk+fr6avHixc3aHgAAAAAAAOBKnDqSW0ZGhvr27SuDwSCDwSCTyaT333/ftr+srEyJiYnq0KGD2rZtq/j4eBUUFNgdgzdOAQAAAAAA4Ek2bdqkyZMn65ZbblG/fv20evVq5eXlKTs7265cQECAjEajbTEYDLZ9H3zwgXJzc/Xaa6+pf//+GjVqlBYuXKj09HSdO3euuZsEAAAAAAAAXJZTO7l17txZTz/9tLKzs3Xw4EENGzZM9913n44ePSpJeuSRR7R+/Xq9+eab2rVrl77++muNGzfO9v3aN07PnTunPXv2aM2aNVq9erXmzZvnrCYBAAAAAAAAzaq4uFiSFBISYrd97dq16tixo3r37q2UlBSdPXvWti8rK0t9+vRRWFiYbVtsbKwsFovt2RwAAAAAAADgKpzayS0uLk6jR49W9+7ddfPNN2vRokVq27at9u7dq+LiYq1cuVLPPfechg0bpujoaK1atUp79uzR3r17JfHGqcfp2LFmAQAAAEA+BgBIkqqrqzVr1izdcccd6t27t237Aw88oNdee007duxQSkqKXn31VT344IO2/Waz2a6DmyTbZ7PZXOe5ysvLZbFY7JZG4zoGAABaoLS0NA0YMEDt2rVTaGioxo4dq2PHjtmVGTJkiLy8vOyW6dOn25VhJisAaEG4/wUcppWzK1CrqqpKb775pkpLS2UymZSdna2KigqNGDHCVqZnz57q0qWLsrKyNGjQoHrfOJ0xY4aOHj2qW2+91RlNQVMIDJS++cbZtQAAAABcA/kYAPCTxMREHTlyRB9++KHd9mnTptnW+/Tpo06dOmn48OE6efKkunXr1qhzpaWlacGCBddUX0lcxwAAQIu1a9cuJSYmasCAAaqsrNTjjz+umJgY5ebmKjAw0FZu6tSpSk1NtX0OCAiwrdfOZGU0GrVnzx7l5+dr0qRJ8vX11eLFi5u1PQCAa8T9L+BQTu/kdvjwYZlMJpWVlalt27Zat26doqKilJOTIz8/PwUHB9uVDwsLs71N2pg3TqWat07Ly8ttn6/prVMAAAAAAADACZKSkrRhwwbt3r1bnTt3vmzZgQMHSpJOnDihbt26yWg0av/+/XZlCgoKJElGo7HOY6SkpCg5Odn22WKxKCIi4lqaAAAA0KJs2rTJ7vPq1asVGhqq7OxsDR482LY9ICCg3sxVO5PV1q1bFRYWpv79+2vhwoWaM2eO5s+fLz8/vyZtAwAAgKty6nSlktSjRw/l5ORo3759mjFjhhISEpSbm9uk50xLS1NQUJBt4WEcAAAAAAAA3IXValVSUpLWrVun7du3KzIy8orfycnJkSR16tRJkmQymXT48GEVFhbaymzZskUGg0FRUVF1HsPf318Gg8FuAQAAQP2Ki4slSSEhIXbb165dq44dO6p3795KSUnR2bNnbfvqm8nKYrHo6NGjdZ7HodPKAwAAuCind3Lz8/PTTTfdpOjoaKWlpalfv3564YUXZDQade7cORUVFdmVLygosL3ZYDQabW+YXri/dl99UlJSVFxcbFu+/PJLxzYKjvfjj9KQITXLjz86uzYAAACAc5GPAcCjJSYm6rXXXlNmZqbatWsns9kss9msH3+6Jpw8eVILFy5Udna2Tp8+rffee0+TJk3S4MGD1bdvX0lSTEyMoqKiNHHiRH366afavHmz5s6dq8TERPn7+zdtA7iOAQAAD1BdXa1Zs2bpjjvuUO/evW3bH3jgAb322mvasWOHUlJS9Oqrr+rBBx+07W/MTFYM8AEALor7X8ChnD5d6cWqq6tVXl6u6Oho+fr6atu2bYqPj5ckHTt2THl5eTKZTJJq3jhdtGiRCgsLFRoaKunKb5xKNW+dNvnDOjhWdbW0a9f5dQAAAMCTkY8BwKNlZGRIkoYMGWK3fdWqVZo8ebL8/Py0detWLV26VKWlpYqIiFB8fLzmzp1rK+vj46MNGzZoxowZMplMCgwMVEJCglJTU5u+AVzHAACAB0hMTNSRI0f04Ycf2m2fNm2abb1Pnz7q1KmThg8frpMnT6pbt26NOhfTygOAi+L+F3Aop3ZyS0lJ0ahRo9SlSxf98MMPyszM1M6dO7V582YFBQVpypQpSk5OVkhIiAwGg2bOnCmTyaRBgwZJsn/jdMmSJTKbzc33xikAAAAAAADgBFar9bL7IyIitKv2IfpldO3aVRs3bnRUtQAAAPCTpKQkbdiwQbt371bnzp0vW3bgwIGSpBMnTqhbt24yGo3av3+/XZkrzWTFAB8AAMATOLWTW2FhoSZNmqT8/HwFBQWpb9++2rx5s+6++25J0vPPPy9vb2/Fx8ervLxcsbGxWr58ue37Tn3jFAAAAAAAAAAAAAB+YrVaNXPmTK1bt047d+5UZGTkFb+Tk5MjSerUqZOkxs9kBQAA0NI5tZPbypUrL7u/devWSk9PV3p6er1leOMUAHAt4uJq/rt+vXPrAQAAADgDeRgAAPdSe+0G4JoSExOVmZmpd999V+3atZPZbJYkBQUFqU2bNjp58qQyMzM1evRodejQQYcOHdIjjzyiwYMHq2/fvpKYyQoAAKA+Tu3kBgBAc+IhIAAAAAAAAACgqWRkZEiShgwZYrd91apVmjx5svz8/LR161YtXbpUpaWlioiIUHx8vObOnWsry0xWAAAAdaOTGwAAAAAAAAAAAABcI6vVetn9ERER2rVr1xWPw0xWAAAAl6KTG9xHQICzawAAAAC4DvIx4JYYXRj4CdcxAAAAAIAn4P4XcBg6ucE9BAZKpaXOrgWARrjwR7z1651XDwAAWhTyMeB26NwGXIDrGAAAAADAE3D/CziUt7MrAAAAAAAAAAAAAAAAAABAfejkBgAAAAAAAAAAAAAAAABwWXRyg3soK5PGjKlZysqcXRsAAADAucjHAAB3xnUMAAAAAOAJuP8FHKqVsysANEhVlbRx4/l1AC1OXJyzawAAgBshHwMA3BnXMQAAAACAJ+D+F3AoOrkBAAAAAAA0EV7mAAAAAAAAAIBrx3SlAAAAAAAAAAAAAAAAAACXRSc3AAAAAAAAAAAAAAAAAIDLopMbAAAAAAAAAAAAAAAAAMBl0ckNAAAAAAAAAAAAAAAAAOCy6OQGAAAAAAAAAAAAAAAAAHBZrZxdAaBBAgMlq9XZtQAAAABcA/kYAODOuI4BAAAAADwB97+AQzGSGwAAAC6RlpamAQMGqF27dgoNDdXYsWN17NgxuzJDhgyRl5eX3TJ9+nS7Mnl5eRozZowCAgIUGhqq2bNnq7KysjmbAgAAAAAAAAAAAMDNMZIbAAAALrFr1y4lJiZqwIABqqys1OOPP66YmBjl5uYqMDDQVm7q1KlKTU21fQ4ICLCtV1VVacyYMTIajdqzZ4/y8/M1adIk+fr6avHixc3aHgAAAAAAAAAAAFy7uDhn1wCeik5ucA9lZdLEiTXrr74qtW7t3PoAANDCbdq0ye7z6tWrFRoaquzsbA0ePNi2PSAgQEajsc5jfPDBB8rNzdXWrVsVFham/v37a+HChZozZ47mz58vPz+/Jm0D0KKRjwEA7ozrGAAAAADAE3D/CzgU05XCPVRVSW+9VbNUVTm7NgAAeJzi4mJJUkhIiN32tWvXqmPHjurdu7dSUlJ09uxZ276srCz16dNHYWFhtm2xsbGyWCw6evRo81QcaKnIxwAAd8Z1DAAAAADgCbj/BRyKkdwAAABwWdXV1Zo1a5buuOMO9e7d27b9gQceUNeuXRUeHq5Dhw5pzpw5OnbsmN5++21JktlstuvgJsn22Ww213mu8vJylZeX2z5bLBZHNwcAAAAAAAAAAACAm6GTGwAAAC4rMTFRR44c0Ycffmi3fdq0abb1Pn36qFOnTho+fLhOnjypbt26NepcaWlpWrBgwTXVFwAAAAAAAAAAAEDLwnSlAIBmExdXswBwH0lJSdqwYYN27Nihzp07X7bswIEDJUknTpyQJBmNRhUUFNiVqf1sNBrrPEZKSoqKi4tty5dffnmtTQAAAAAAAE2AZ30AAAAAmhOd3AAAAHAJq9WqpKQkrVu3Ttu3b1dkZOQVv5OTkyNJ6tSpkyTJZDLp8OHDKiwstJXZsmWLDAaDoqKi6jyGv7+/DAaD3QIAAAAAAFwXnd0AAAAANAemKwUAAMAlEhMTlZmZqXfffVft2rWT2WyWJAUFBalNmzY6efKkMjMzNXr0aHXo0EGHDh3SI488osGDB6tv376SpJiYGEVFRWnixIlasmSJzGaz5s6dq8TERPn7+zuzeQAAAAAAAAAAAADcCCO5AQAA4BIZGRkqLi7WkCFD1KlTJ9vyj3/8Q5Lk5+enrVu3KiYmRj179tSjjz6q+Ph4rV+/3nYMHx8fbdiwQT4+PjKZTHrwwQc1adIkpaamOqtZAAAAAAAAAAAAANwQI7nBPQQESCUl59cBAECTslqtl90fERGhXbt2XfE4Xbt21caNGx1VLQC1yMcAAHfGdQwAAAAA4Am4/wUcik5ucA9eXlJgoLNrAQAAALgG8jEAwJ1xHQMAAAAAeALufwGHYrpSAAAAAAAAAAAAAAAAAIDLopMb3EN5uTR5cs1SXu7s2gAAAADORT4GALgzrmMAAAAAAE/A/S/gUHRyg3uorJTWrKlZKiudXRsAAADAucjHAAB3xnUMABokLq5mAQAAgJvi/hdwqFbOrgAAAK6g9oHh+vXOrQcAAAAAAAA8Gx3bAAAAAOBSjOQGAAAAAAAAAAAAAAAAAHBZdHIDAAAAAAAAAABwcYzwBgAAAMCTMV0pAMBheNAGAAAAAAAAAAAAAAAcjZHcAAAAAAAAAAAAAAAAAAAui05uAAAAAAAAAAAAAAAAAOzExTGbF1wH05XCPQQESIWF59cBAAAAT0Y+BgC4M65jAAAAAABPwP0v4FBOHcktLS1NAwYMULt27RQaGqqxY8fq2LFjdmWGDBkiLy8vu2X69Ol2ZfLy8jRmzBgFBAQoNDRUs2fPVmVlZXM2BU3Ny0u67rqaxcvL2bUBAAAAnIt8DABwZ1zHAAAAAACegPtfwKGcOpLbrl27lJiYqAEDBqiyslKPP/64YmJilJubq8DAQFu5qVOnKjU11fY54IIerlVVVRozZoyMRqP27Nmj/Px8TZo0Sb6+vlq8eHGztgcAAAAAAAAAAAAAAAAA4FhO7eS2adMmu8+rV69WaGiosrOzNXjwYNv2gIAAGY3GOo/xwQcfKDc3V1u3blVYWJj69++vhQsXas6cOZo/f778/PyatA1oJuXlUnJyzfpzz0n+/s6tDwAAAOBM5GMATSgurua/69c7tx5owbiOAQAAAAA8Afe/gEM5dbrSixUXF0uSQkJC7LavXbtWHTt2VO/evZWSkqKzZ8/a9mVlZalPnz4KCwuzbYuNjZXFYtHRo0frPE95ebksFovdAhdXWSktX16zMBUtAAAAPB35GADgzriOAQAAAAA8Afe/gEM5dSS3C1VXV2vWrFm644471Lt3b9v2Bx54QF27dlV4eLgOHTqkOXPm6NixY3r77bclSWaz2a6DmyTbZ7PZXOe50tLStGDBgiZqCQAAAAAAAAAAAAAAANAy1I78DziTy3RyS0xM1JEjR/Thhx/abZ82bZptvU+fPurUqZOGDx+ukydPqlu3bo06V0pKipJrh4SUZLFYFBER0biKAwAAAAAAAAAAAAAAAACajEtMV5qUlKQNGzZox44d6ty582XLDhw4UJJ04sQJSZLRaFRBQYFdmdrPRqOxzmP4+/vLYDDYLQAAAAAAAAAAAAAAAAAA1+PUkdysVqtmzpypdevWaefOnYqMjLzid3JyciRJnTp1kiSZTCYtWrRIhYWFCg0NlSRt2bJFBoNBUVFRTVZ3AAAAAACAC6dqWL/eefUAAAAAAAAA0Dg843MPTh3JLTExUa+99poyMzPVrl07mc1mmc1m/fjjj5KkkydPauHChcrOztbp06f13nvvadKkSRo8eLD69u0rSYqJiVFUVJQmTpyoTz/9VJs3b9bcuXOVmJgof39/ZzYPAAAAAAAAcLi0tDQNGDBA7dq1U2hoqMaOHatjx47ZlSkrK1NiYqI6dOigtm3bKj4+/pLZEPLy8jRmzBgFBAQoNDRUs2fPVmVlZXM2BQAAAAAAAGgQp3Zyy8jIUHFxsYYMGaJOnTrZln/84x+SJD8/P23dulUxMTHq2bOnHn30UcXHx2v9Bd0mfXx8tGHDBvn4+MhkMunBBx/UpEmTlJqa6qxmAQAAAAAAuJW4uPMLXN+uXbuUmJiovXv3asuWLaqoqFBMTIxKS0ttZR555BGtX79eb775pnbt2qWvv/5a48aNs+2vqqrSmDFjdO7cOe3Zs0dr1qzR6tWrNW/ePGc0CQAAAAAAALgsp09XejkRERHatWvXFY/TtWtXbdy40VHVgitq00Y6der8OgAAAODJyMcA4NE2bdpk93n16tUKDQ1Vdna2Bg8erOLiYq1cuVKZmZkaNmyYJGnVqlXq1auX9u7dq0GDBumDDz5Qbm6utm7dqrCwMPXv318LFy7UnDlzNH/+fPn5+TVdA7iOAQAAAAA8Afe/gEM5dSQ3oMG8vaUbbqhZvPm/LQAAADwc+RhwSYyEBmcpLi6WJIWEhEiSsrOzVVFRoREjRtjK9OzZU126dFFWVpYkKSsrS3369FFYWJitTGxsrCwWi44ePVrnecrLy2WxWOyWRuE6BgAAWiimlQcA2OH+F3Ao/hYBAAAAAAA4EFN/ojlVV1dr1qxZuuOOO9S7d29Jktlslp+fn4KDg+3KhoWFyWw228pc2MGtdn/tvrqkpaUpKCjItkRERDi4NQCAupArAPfBtPIAAABNx6nTlQINdu6c9Kc/1awvWiQ15ZQZAAAAgKsjHwMAfpKYmKgjR47oww8/bPJzpaSkKDk52fbZYrE0rqMb1zEAANBCuf208gAAx+L+F3AoRnKDe6iokJ59tmapqHB2bQAAAADnIh8DACQlJSVpw4YN2rFjhzp37mzbbjQade7cORUVFdmVLygokNFotJW5eFqs2s+1ZS7m7+8vg8FgtzQK1zEAAOAh3G5aeQCAY3H/CzgUndwAAAAAAAAAN2K1WpWUlKR169Zp+/btioyMtNsfHR0tX19fbdu2zbbt2LFjysvLk8lkkiSZTCYdPnxYhYWFtjJbtmyRwWBQVFRU8zQEAACgBWNaeQAAAMdiulIAAAAAAADAjSQmJiozM1Pvvvuu2rVrZ/uxMygoSG3atFFQUJCmTJmi5ORkhYSEyGAwaObMmTKZTBo0aJAkKSYmRlFRUZo4caKWLFkis9msuXPnKjExUf7+/s5sHgAAQIvgltPKAwAAuDA6uQEAAAAAAABuJCMjQ5I0ZMgQu+2rVq3S5MmTJUnPP/+8vL29FR8fr/LycsXGxmr58uW2sj4+PtqwYYNmzJghk8mkwMBAJSQkKDU1tbmaAQAA0GLVTiu/e/fueqeVv3A0t4unld+/f7/d8RoyrTwvKgAAgJaOTm4AAAAAAACAG7FarVcs07p1a6Wnpys9Pb3eMl27dtXGjRsdWTUAAACPZrVaNXPmTK1bt047d+687LTy8fHxkuqeVn7RokUqLCxUaGioJKaVBwAAkOjkBgAAAAAAAAAAAADXjGnlAQAAmg6d3AAAAAAAAAAAAADgGjGtPAAAQNOhkxvcQ5s20pEj59cBAAAAT0Y+BtAM4uLOr69f77x6oAXiOgYAAFooppUHANjh/hdwKDq5wT14e0u33OLsWgAAAACugXwMAHBnXMcAAAAAAJ6A+1/AobydXQEAAAAAAAAAAAAAAAAAAOrDSG5wD+fOSYsX16w//rjk5+fc+gAAAADORD4GALgzrmMAAAAAAE/A/S/gUHRyg3uoqJAWLKhZnz2bf/wBAADg2cjHAAB3xnUMAAAAAOAJuP8FHIrpSgEAAAAAAAAAAAAAAAAALotObgAAAAAAAAAAAAAAAAAAl0UnNwAAAAAAAAAAAAAAAACAy6KTGwAAAAAAAAAAAAAAAADAZdHJDQAAAJdIS0vTgAED1K5dO4WGhmrs2LE6duyYXZmysjIlJiaqQ4cOatu2reLj41VQUGBXJi8vT2PGjFFAQIBCQ0M1e/ZsVVZWNmdTAAAAAABAM4qLq1kAAAAAwJHo5AYAAIBL7Nq1S4mJidq7d6+2bNmiiooKxcTEqLS01FbmkUce0fr16/Xmm29q165d+vrrrzVu3Djb/qqqKo0ZM0bnzp3Tnj17tGbNGq1evVrz5s1zRpMAAAAAAAAAAAAAuKlGdXK78cYb9d13312yvaioSDfeeOM1Vwq4ROvW0v79NUvr1s6uDQAPU/v2KW+gwh04Kqdt2rRJkydP1i233KJ+/fpp9erVysvLU3Z2tiSpuLhYK1eu1HPPPadhw4YpOjpaq1at0p49e7R3715J0gcffKDc3Fy99tpr6t+/v0aNGqWFCxcqPT1d586dc0yDAU9FPgYAt8QztZ9wHQMAAC6GnAYAaBLc/wIO1ahObqdPn1ZVVdUl28vLy/XVV19dc6WAS/j4SAMG1Cw+Ps6uDQAALqupclpxcbEkKSQkRJKUnZ2tiooKjRgxwlamZ8+e6tKli7KysiRJWVlZ6tOnj8LCwmxlYmNjZbFYdPTo0UbXBYDIxwDgpnim9hOuYwAAwMWQ0wAATYL7X8ChWl1N4ffee8+2vnnzZgUFBdk+V1VVadu2bbrhhhscVjkAAAA0TFPmtOrqas2aNUt33HGHevfuLUkym83y8/NTcHCwXdmwsDCZzWZbmQs7uNXur91Xl/LycpWXl9s+WyyWRtUZAADAlfBMDQDgCZgFAe6InAYAAOA+rqqT29ixYyVJXl5eSkhIsNvn6+urG264QX/5y18cVjnA5tw56YUXatYffljy83NufQBIOv/gav1659YDQNPmtMTERB05ckQffvjhtVbzitLS0rRgwYImPw/g9sjHAOBWeKZ2Ea5jAOBReIYIV0ZOAwA0Ke5/AYe6qk5u1dXVkqTIyEgdOHBAHTt2bJJKAZeoqJAee6xm/b//m3/8AQC4SFPltKSkJG3YsEG7d+9W586dbduNRqPOnTunoqIiu9HcCgoKZDQabWX2799vd7yCggLbvrqkpKQoOTnZ9tlisSgiIsIhbQFaFPIxALgVnqldhOsYANSJkdCA5kdOAwA0Ke5/AYfybsyXTp06RcgDAABwQY7KaVarVUlJSVq3bp22b9+uyMhIu/3R0dHy9fXVtm3bbNuOHTumvLw8mUwmSZLJZNLhw4dVWFhoK7NlyxYZDAZFRUXVeV5/f38ZDAa7BQAAoKXgmRoAAIBrIqcBAAC4vqsaye1C27Zt07Zt21RYWGh7y6HWyy+/fM0VAwAAQOM4IqclJiYqMzNT7777rtq1ayez2SxJCgoKUps2bRQUFKQpU6YoOTlZISEhMhgMmjlzpkwmkwYNGiRJiomJUVRUlCZOnKglS5bIbDZr7ty5SkxMlL+/v2MbDQAA4CZ4pgYAAOCayGkAAEA6P8Ly+vXOrQcu1ahObgsWLFBqaqpuu+02derUSV5eXo6uFwAATscUEXBHjsppGRkZkqQhQ4bYbV+1apUmT54sSXr++efl7e2t+Ph4lZeXKzY2VsuXL7eV9fHx0YYNGzRjxgyZTCYFBgYqISFBqampjaoTAACuhKyIxuCZGgAAgGsipwEAALi+RnVyW7FihVavXq2JEyc6uj4AADgVP1bC3Tkqp1mt1iuWad26tdLT05Wenl5vma5du2rjxo3XVBcAAICWgmdqAAAAromcBgAA4Poa1cnt3Llz+tnPfubougAAAOAakdMAAABcF1kNAADANZHTAADAxS4cHIWpS12Dd2O+9Pvf/16ZmZmOrgsAAACuETkNAADAdZHVAAAAXBM5DQAAwPU1aiS3srIyvfTSS9q6dav69u0rX19fu/3PPfecQyoH2LRuLe3YcX4dAADUiZwGeAjyMQC4JbLaT7iOAQAAF0NOAwA0Ce5/AYdqVCe3Q4cOqX///pKkI0eO2O3z8vK65koBl/DxkYYMcXYtAABweeQ0wEOQjwHALZHVfsJ1DAAAuBhyGgCgSbjZ/W/t9JxMzQlX1ahObjtqe5oCAADApZDTAAAAXBdZDQAAwDWR0wAAAFxfozq5Ac2uokJ66aWa9WnTpIuGiQYAAAA8CvkYAODOuI4BgJ3aETMAAADQwnD/CzhUozq5DR069LJD827fvr1Bx0lLS9Pbb7+tzz//XG3atNHPfvYzPfPMM+rRo4etTFlZmR599FG98cYbKi8vV2xsrJYvX66wsDBbmby8PM2YMUM7duxQ27ZtlZCQoLS0NLVqRR++FuPcOSkpqWZ98mT+8QcAoB6OymkAXBz5GADcElntJ1zHAACAiyGnAQCaBPe/gEM1qhdY7Zz0tSoqKpSTk6MjR44oISGhwcfZtWuXEhMTNWDAAFVWVurxxx9XTEyMcnNzFRgYKEl65JFH9K9//UtvvvmmgoKClJSUpHHjxumjjz6SJFVVVWnMmDEyGo3as2eP8vPzNWnSJPn6+mrx4sWNaR4AAIDbclROAwAAgOOR1QAAAFwTOQ0AAMD1NaqT2/PPP1/n9vnz56ukpKTBx9m0aZPd59WrVys0NFTZ2dkaPHiwiouLtXLlSmVmZmrYsGGSpFWrVqlXr17au3evBg0apA8++EC5ubnaunWrwsLC1L9/fy1cuFBz5szR/Pnz5efn15gmAgAAuCVH5TQAAAA4HlkNAADANZHTAAAAXJ+3Iw/24IMP6uWXX27094uLiyVJISEhkqTs7GxVVFRoxIgRtjI9e/ZUly5dlJWVJUnKyspSnz597KYvjY2NlcVi0dGjRxtdFwAAgJbkWnMaAADwbHFxNQuaBlkNAADANZHTAAAAXEejRnKrT1ZWllq3bt2o71ZXV2vWrFm644471Lt3b0mS2WyWn5+fgoOD7cqGhYXJbDbbylzYwa12f+2+upSXl6u8vNz22WKxNKrOAAAA7uJachoAAACaFlkNAADANZHTAAAAXEejOrmNGzfO7rPValV+fr4OHjyoJ554olEVSUxM1JEjR/Thhx826vtXIy0tTQsWLGjy8wAAADS3pshpAAAAcAyyGgAAgGsipwEAALi+RnVyCwoKsvvs7e2tHj16KDU1VTExMVd9vKSkJG3YsEG7d+9W586dbduNRqPOnTunoqIiu9HcCgoKZDQabWX2799vd7yCggLbvrqkpKQoOTnZ9tlisSgiIuKq6w0AAOBqHJ3TAAAA4DhkNQAAANdETgMAAHB9jerktmrVKoec3Gq1aubMmVq3bp127typyMhIu/3R0dHy9fXVtm3bFB8fL0k6duyY8vLyZDKZJEkmk0mLFi1SYWGhQkNDJUlbtmyRwWBQVFRUnef19/eXv7+/Q9qAZuLvL23YcH4dAADUyVE5DYCLIx8DgFsiq/2E6xgASJLi4pxdAwC1yGkAgCbB/S/gUI3q5FYrOztbn332mSTplltu0a233npV309MTFRmZqbeffddtWvXTmazWVLN2xJt2rRRUFCQpkyZouTkZIWEhMhgMGjmzJkymUwaNGiQJCkmJkZRUVGaOHGilixZIrPZrLlz5yoxMZGObC1Jq1bSmDHOrgUAAG7jWnMaABdHPgYAt+bxWY3rGAAAcFEen9MAAI7F/W+LUfuCyvr1zq2Hp2tUJ7fCwkKNHz9eO3futE0jWlRUpKFDh+qNN97Qdddd16DjZGRkSJKGDBlit33VqlWaPHmyJOn555+Xt7e34uPjVV5ertjYWC1fvtxW1sfHRxs2bNCMGTNkMpkUGBiohIQEpaamNqZpAAAAbs1ROQ0AAACOR1YDAABwTeQ0AADOY8RhuCrvxnxp5syZ+uGHH3T06FGdOXNGZ86c0ZEjR2SxWPTQQw81+DhWq7XOpbaDmyS1bt1a6enpOnPmjEpLS/X222/LaDTaHadr167auHGjzp49q2+++UbPPvusWrW6pkHq4GoqKqTVq2uWigpn1wYAAJflqJwGwMWRjwHALZHVfsJ1DAAAuBhyGgCgSXD/CzhUo3qCbdq0SVu3blWvXr1s26KiopSenq6YmBiHVQ6wOXdO+u1va9bvv1/y9XVufQAAcFHkNMBDkI8BwC2R1X7CdQwAALgYchoAoElw/ws4VKM6uVVXV8u3jr98vr6+qq6uvuZKAQAAoHHIaQAAAK6LrAYAkJj+CXBF5DQAgKcim8KdNGq60mHDhunhhx/W119/bdv21Vdf6ZFHHtHw4cMdVjkAAABcHXIaAACA6yKrAQAAuCZyGgAAgOtrVCe3v/71r7JYLLrhhhvUrVs3devWTZGRkbJYLHrxxRcdXUcAgIuLi6OXP+AqyGkAAACui6wGAADgmshpAAAArq9R05VGRETo448/1tatW/X5559Lknr16qURI0Y4tHIAAAC4OuQ0AAAA10VWAwAAcE3kNAAAANd3VSO5bd++XVFRUbJYLPLy8tLdd9+tmTNnaubMmRowYIBuueUW/d///V9T1RUAAAD1IKcBAAC4LrIaAMATMfsD3AE5DQAAwH1cVSe3pUuXaurUqTIYDJfsCwoK0h/+8Ac999xzDqscAAAAGoacBgAA4LrIagAAAK6JnAYAAOA+rqqT26effqqRI0fWuz8mJkbZ2dnXXCngEv7+0v/+b83i7+/s2gAA4HLIaYCHIR8DgFtxdFbbvXu34uLiFB4eLi8vL73zzjt2+ydPniwvLy+75eLznzlzRhMmTJDBYFBwcLCmTJmikpKSq2pXo3EdAwAALoJnagCAJsX9L+BQra6mcEFBgXx9fes/WKtW+uabb665UsAlWrWS7r/f2bUAAMBlkdMAD0M+BuAktVOOrV/v3Hq4G0dntdLSUvXr10+/+93vNG7cuDrLjBw5UqtWrbJ99r/oYfqECROUn5+vLVu2qKKiQr/97W81bdo0ZWZmNrgejcZ1DAAAuAieqQEAmhT3v4BDXdVIbtdff72OHDlS7/5Dhw6pU6dO11wpAAAAXB1yGgAAzSMu7nxHL6ChHJ3VRo0apaeeekq/+MUv6i3j7+8vo9FoW9q3b2/b99lnn2nTpk36+9//roEDB+rOO+/Uiy++qDfeeENff/11g+sBAADg7primZrbj7oLAADgoq6qk9vo0aP1xBNPqKys7JJ9P/74o5588kndc889DqscYFNZKb35Zs1SWens2gAA4HLIaYCHIR8DgFtxRlbbuXOnQkND1aNHD82YMUPfffedbV9WVpaCg4N122232baNGDFC3t7e2rdvn0PrUSeuYwAAwEU0RU6rHXU3PT293jIjR45Ufn6+bXn99dft9k+YMEFHjx7Vli1btGHDBu3evVvTpk27qnoAAFwA97+AQ13VdKVz587V22+/rZtvvllJSUnq0aOHJOnzzz9Xenq6qqqq9Kc//alJKgoPV14u/epXNeslJTXDegIAABtyGuBhyMcA4FaaO6uNHDlS48aNU2RkpE6ePKnHH39co0aNUlZWlnx8fGQ2mxUaGmr3nVatWikkJERms7ne45aXl6u8vNz22WKxNK6CXMcAAICLaIqcNmrUKI0aNeqyZWpH3a1L7ai7Bw4csL2U8OKLL2r06NF69tlnFR4eflX1AQA4Efe/gENd1d+gsLAw7dmzRzNmzFBKSoqsVqskycvLS7GxsUpPT1dYWFiTVBQAAAD1I6cBAAC4rubOauPHj7et9+nTR3379lW3bt20c+dODR8+vNHHTUtL04IFCxxRRQAAAJfgrGdqtaPutm/fXsOGDdNTTz2lDh06SLryqLuXm7IeAACgJbvqbqJdu3bVxo0b9f333+vEiROyWq3q3r272rdv3xT1AwAAQAOR0wAAAFyXM7PajTfeqI4dO+rEiRMaPny4jEajCgsL7cpUVlbqzJkz9Y4oIkkpKSlKTk62fbZYLIqIiGiyegMAADSH5s5pTTHqrsNG3AUAAHBhjR4LsX379howYIAj6wIAAAAHIKcBAAC4Lmdktf/85z/67rvv1KlTJ0mSyWRSUVGRsrOzFR0dLUnavn27qqurNXDgwHqP4+/vL39//2apMwAAQHNrrpzWFKPuMuIuAADwBN7OrgAAAAAAAACAhispKVFOTo5ycnIkSadOnVJOTo7y8vJUUlKi2bNna+/evTp9+rS2bdum++67TzfddJNiY2MlSb169dLIkSM1depU7d+/Xx999JGSkpI0fvx4hYeHO7FlAAAAnufCUXclNWrU3ZSUFBUXF9uWL7/8ssnrDQAA0Nzo5AYAAAAAAAC4kYMHD+rWW2/VrbfeKklKTk7Wrbfeqnnz5snHx0eHDh3Svffeq5tvvllTpkxRdHS0/u///s9uFLa1a9eqZ8+eGj58uEaPHq0777xTL730krOaBAAA4LEuN+purSuNuuvv7y+DwWC3AAAAtDSNnq4UAAAAAAAAQPMbMmSIrFZrvfs3b958xWOEhIQoMzPTkdUCAACAakbdrR2VTTo/6m5ISIhCQkK0YMECxcfHy2g06uTJk3rsscfqHXV3xYoVqqioYNRdAAAA0ckN7sLPT1q16vw6gGYXF1fz3/XrnVsPAAAg8jEAwL1xHQMAAC3YwYMHNXToUNvn5ORkSVJCQoIyMjJ06NAhrVmzRkVFRQoPD1dMTIwWLlx4yai7SUlJGj58uLy9vRUfH69ly5Y1e1sAANeI+1/AoejkBvfg6ytNnuzsWgAAAACugXwMAHBnXMcAAEALxqi7AAAb7n8Bh6KTGwDgqtSO6AYAAAAAAAAAAAAAANAc6OQG91BZKdW+2RIbK7Xi/7oAAADwYORjAIA74zoGAAAAAPAE3P8CDsXfILiH8nLpnntq1ktK+McfAAAAno18DDQrRjMGHIzrGAAAAADAE3D/CziUt7MrAAAAAAAAAAAAAAAAAABAfejkBgAAgDrt3r1bcXFxCg8Pl5eXl9555x27/ZMnT5aXl5fdMnLkSLsyZ86c0YQJE2QwGBQcHKwpU6aopKSkGVsBAAAAAAAAAAAAwN3RyQ0AAAB1Ki0tVb9+/ZSenl5vmZEjRyo/P9+2vP7663b7J0yYoKNHj2rLli3asGGDdu/erWnTpjV11QEAAAAAAAAAAAC0IEz4CwAAgDqNGjVKo0aNumwZf39/GY3GOvd99tln2rRpkw4cOKDbbrtNkvTiiy9q9OjRevbZZxUeHu7wOgMAAAAAAAAAAABoeRjJDQCAqxAXV7MAqLFz506FhoaqR48emjFjhr777jvbvqysLAUHB9s6uEnSiBEj5O3trX379tV5vPLyclksFrsFAAAAAAAAAAAAgGejkxsAAAAaZeTIkXrllVe0bds2PfPMM9q1a5dGjRqlqqoqSZLZbFZoaKjdd1q1aqWQkBCZzeY6j5mWlqagoCDbEhER0eTtAAAAAAAAAAAAAODamK4U7sHPT/rrX8+vAwAApxs/frxtvU+fPurbt6+6deumnTt3avjw4Y06ZkpKipKTk22fLRYLHd2AupCPAQDujOsYAAAAAMATcP8LOBSd3OAefH2lxERn1wIAAFzGjTfeqI4dO+rEiRMaPny4jEajCgsL7cpUVlbqzJkzMhqNdR7D399f/v7+zVFdwL2RjwEA7ozrGAAAAADAE3D/CzgU05UCAADAIf7zn//ou+++U6dOnSRJJpNJRUVFys7OtpXZvn27qqurNXDgQGdVEwAAAAAAOEFcXM0CAAAAAI3BSG5wD1VV0v/9X836z38u+fg4tz4AAHiAkpISnThxwvb51KlTysnJUUhIiEJCQrRgwQLFx8fLaDTq5MmTeuyxx3TTTTcpNjZWktSrVy+NHDlSU6dO1YoVK1RRUaGkpCSNHz9e4eHhzmoW0DKQjwEA7ozrGAAAAADAE3D/CzgUndzgHsrKpKFDa9ZLSqTAQOfWBwAAD3Dw4EENrb3+SkpOTpYkJSQkKCMjQ4cOHdKaNWtUVFSk8PBwxcTEaOHChXbTja5du1ZJSUkaPny4vL29FR8fr2XLljV7W4AWh3wMAHBnXMcAAAAAAJ6A+1/AoejkBgAAgDoNGTJEVqu13v2bN2++4jFCQkKUmZnpyGoBAAAAAAAAAAAAzS4u7vz6+vXOq4enopMbAAAAAAAAAABAE7vwBzEAAACgudXmUTpnwV3RyQ0AAAAAAOAC/AANAAAAAAAAAK7F25kn3717t+Li4hQeHi4vLy+98847dvsnT54sLy8vu2XkyJF2Zc6cOaMJEybIYDAoODhYU6ZMUUlJSTO2AgAAAAAAAAAAAAAAAHB9cXHnF8CdOLWTW2lpqfr166f09PR6y4wcOVL5+fm25fXXX7fbP2HCBB09elRbtmzRhg0btHv3bk2bNq2pqw4ALRqhBgAAAAAAAAAAAAAAuAqnTlc6atQojRo16rJl/P39ZTQa69z32WefadOmTTpw4IBuu+02SdKLL76o0aNH69lnn1V4eLjD6wwAAAAAAAAAAAAAAAAAaD5O7eTWEDt37lRoaKjat2+vYcOG6amnnlKHDh0kSVlZWQoODrZ1cJOkESNGyNvbW/v27dMvfvGLOo9ZXl6u8vJy22eLxdK0jcC18/WVliw5vw6gWTCaGwAALop8DMCF1N43rF/v3HrAjXAdAwAAAAB4Au5/AYdy6U5uI0eO1Lhx4xQZGamTJ0/q8ccf16hRo5SVlSUfHx+ZzWaFhobafadVq1YKCQmR2Wyu97hpaWlasGBBU1cfjuTnJ82e7exaAAAAAK6BfAwAcGdcxwAAAAAAnoD7X49w4cAxvATatFy6k9v48eNt63369FHfvn3VrVs37dy5U8OHD2/0cVNSUpScnGz7bLFYFBERcU11BQAAAAAA7otRjAEAAAAAAADAdXk7uwJX48Ybb1THjh114sQJSZLRaFRhYaFdmcrKSp05c0ZGo7He4/j7+8tgMNgtcHFVVdKBAzVLVZWzawMAAAA4F/kYAODOuI4BAAAAADwB97+AQ7n0SG4X+89//qPvvvtOnTp1kiSZTCYVFRUpOztb0dHRkqTt27erurpaAwcOdGZV4WhlZdLtt9esl5RIgYHOrQ8AAADgTORjAIA74zoGAAAAAPAE3P8CDuXUTm4lJSW2Udkk6dSpU8rJyVFISIhCQkK0YMECxcfHy2g06uTJk3rsscd00003KTY2VpLUq1cvjRw5UlOnTtWKFStUUVGhpKQkjR8/XuHh4c5qFgAAAAAAAAAAAAAAAADAQZzaye3gwYMaOnSo7XNycrIkKSEhQRkZGTp06JDWrFmjoqIihYeHKyYmRgsXLpS/v7/tO2vXrlVSUpKGDx8ub29vxcfHa9myZc3eFgAAAAAAAE8WF3d+ff1659UDAAAAAAAAQMvj1E5uQ4YMkdVqrXf/5s2br3iMkJAQZWZmOrJaAAAAAAAAAAAAAAAAAAAX4e3sCgAAAAAAAAAAAMCzxMXZjwQLAAAAAJdDJzcAAAAAAAAAAAAAAAAAgMty6nSlAAAAAAAAAAAA8ByM3gYAAND0yFxoiejkBvfg6ys9+eT5dQAAAMCTkY8BAO6M6xgAAAAAwBNw/ws4FJ3c4B78/KT5851dCwAAAMA1kI8BAO6M6xgAAAAAwBNw/ws4lLezKwAAAAAAAAAAAAAAAAAAQH0YyQ3uobpa+uyzmvVevSRv+mcCAADAg5GPAQDujOsYAAAAAMATcP8LOBSd3OAefvxR6t27Zr2kRAoMdG59AAAAAGciHwMA3BnXMQAAAACAJ+D+F3AoOrkBAAAAAADgqsTFObsGAAAAAAAAgPPwfKz50ckNAAAAAAAAAACgifDjFwAAAABcOyb8BQDgGsXF8bASAAAAAAAAAAAAAICmQic3AAAAAAAAAAAAAAAAAIDLopMbAAAAAAAAAAAAAAAAAMBl0ckNAAAAAAAAAAAAAAAAAOCyWjm7AkCD+PpKf/zj+XUAcLK4OGfXAADg0cjHAAB3xnUMAAAAAOAJuP8FHIpObnAPfn7Sn//s7FoAAAAAroF8DABwZ1zHAAAAAACegPtfwKGYrhQAAAAAAAAAAAAAAAAA4LLo5Ab3UF0tnT5ds1RXO7s2QIsUF3d+AQAALo58DDgMGRjuaPfu3YqLi1N4eLi8vLz0zjvv2O23Wq2aN2+eOnXqpDZt2mjEiBE6fvy4XZkzZ85owoQJMhgMCg4O1pQpU1RSUtI8DeA6BqCFIU8AAACgTs18/8vvvWjp6OQG9/Djj1JkZM3y44/Org0AAADgXORjAPBopaWl6tevn9LT0+vcv2TJEi1btkwrVqzQvn37FBgYqNjYWJWVldnKTJgwQUePHtWWLVu0YcMG7d69W9OmTWueBnAdAwAALZjbv5AAAHAc7n8Bh6KTGwAAAAAAAOBGRo0apaeeekq/+MUvLtlntVq1dOlSzZ07V/fdd5/69u2rV155RV9//bXtB9bPPvtMmzZt0t///ncNHDhQd955p1588UW98cYb+vrrr5u5NQAAAC2L27+QAAAA4KLo5AYAAAAAAAC0EKdOnZLZbNaIESNs24KCgjRw4EBlZWVJkrKyshQcHKzbbrvNVmbEiBHy9vbWvn376j12eXm5LBaL3QIAAAB7vJAAAADQNOjkBgAAAAAAALQQZrNZkhQWFma3PSwszLbPbDYrNDTUbn+rVq0UEhJiK1OXtLQ0BQUF2ZaIiAgH1x4AAKBla8oXEgAAAFo6OrkBAAAAAAAAuKKUlBQVFxfbli+//NLZVQIAlxIXV7MAQH2a6oUERtwFAACegE5uAAAAAAAAQAthNBolSQUFBXbbCwoKbPuMRqMKCwvt9ldWVurMmTO2MnXx9/eXwWCwWwAA9aPTG4Dmwoi7AADAE9DJDQAAAAAAAGghIiMjZTQatW3bNts2i8Wiffv2yWQySZJMJpOKioqUnZ1tK7N9+3ZVV1dr4MCBzV5nAAAAT9FULyQw4i4AAPAErZxdAaBBWrWS/vu/z68DAAAAnox8DAAeraSkRCdOnLB9PnXqlHJychQSEqIuXbpo1qxZeuqpp9S9e3dFRkbqiSeeUHh4uMaOHStJ6tWrl0aOHKmpU6dqxYoVqqioUFJSksaPH6/w8PCmbwDXMQDABWpHu1u/3rn1AJrDhS8k9O/fX9L5FxJmzJghyf6FhOjoaElXfiHB399f/v7+zdIGAMBV4P7X45BtmxZ/i+Ae/P2l9HRn1wIAAABwDeRjAPBoBw8e1NChQ22fk5OTJUkJCQlavXq1HnvsMZWWlmratGkqKirSnXfeqU2bNql169a276xdu1ZJSUkaPny4vL29FR8fr2XLljVPA7iOAQCAFsztX0gAADgO97+AQ9HJDQAAAAAAAHAjQ4YMkdVqrXe/l5eXUlNTlZqaWm+ZkJAQZWZmNkX1AMDj1Y7eAMAzuf0LCQAAAC7K29kVABrEapW++aZmucxDXAAA4Di7d+9WXFycwsPD5eXlpXfeecduv9Vq1bx589SpUye1adNGI0aM0PHjx+3KnDlzRhMmTJDBYFBwcLCmTJmikpKSZmwF0EKRjwEA7ozrGAAAaMFqX0i4eFm9erWk8y8kmM1mlZWVaevWrbr55pvtjlH7QsIPP/yg4uJivfzyy2rbtq0TWgMAuCbc/wIORSc3uIezZ6XQ0Jrl7Fln1wYA6hQXd34BWoLS0lL169dP6fUMpb1kyRItW7ZMK1as0L59+xQYGKjY2FiVlZXZykyYMEFHjx7Vli1btGHDBu3evVvTpk1rriYALRf5GADgzriOAQAAAAA8Afe/gEMxXSkAAADqNGrUKI0aNarOfVarVUuXLtXcuXN13333SZJeeeUVhYWF6Z133tH48eP12WefadOmTTpw4IBuu+02SdKLL76o0aNH69lnn1V4eHiztQUAAAAAAAAAAACA+2IkNwAAAFy1U6dOyWw2a8SIEbZtQUFBGjhwoLKysiRJWVlZCg4OtnVwk6QRI0bI29tb+/btq/O45eXlslgsdgsAAAAAAAAAAAAAz0YnNwAAAFw1s9ksSQoLC7PbHhYWZttnNpsVGhpqt79Vq1YKCQmxlblYWlqagoKCbEtEREQT1B4AAAAAAAAAAACAO6GTGwB4oLi48wsAuJKUlBQVFxfbli+//NLZVQIAAAAAAAAAAAAahd/lHYdObgAAALhqRqNRklRQUGC3vaCgwLbPaDSqsLDQbn9lZaXOnDljK3Mxf39/GQwGuwUAALgfHt4BAAAAAAAAcCQ6uQEAAOCqRUZGymg0atu2bbZtFotF+/btk8lkkiSZTCYVFRUpOzvbVmb79u2qrq7WwIEDm73OAAAAAAAAAAAAANyTUzu57d69W3FxcQoPD5eXl5feeecdu/1Wq1Xz5s1Tp06d1KZNG40YMULHjx+3K3PmzBlNmDBBBoNBwcHBmjJlikpKSpqxFWgWrVpJCQk1S6tWzq4NAAAeoaSkRDk5OcrJyZEknTp1Sjk5OcrLy5OXl5dmzZqlp556Su+9954OHz6sSZMmKTw8XGPHjpUk9erVSyNHjtTUqVO1f/9+ffTRR0pKStL48eMVHh7uvIYBLQH5GADgzriOAQAAAAA8Afe/gEM59W9RaWmp+vXrp9/97ncaN27cJfuXLFmiZcuWac2aNYqMjNQTTzyh2NhY5ebmqnXr1pKkCRMmKD8/X1u2bFFFRYV++9vfatq0acrMzGzu5qAp+ftLq1c7uxYAAHiUgwcPaujQobbPycnJkqSEhAStXr1ajz32mEpLSzVt2jQVFRXpzjvv1KZNm2w5TZLWrl2rpKQkDR8+XN7e3oqPj9eyZcuavS1Ai0M+BgC4M65jAAAAAABPwP0v4FBO7eQ2atQojRo1qs59VqtVS5cu1dy5c3XfffdJkl555RWFhYXpnXfe0fjx4/XZZ59p06ZNOnDggG677TZJ0osvvqjRo0fr2WefZYQQAACAazBkyBBZrdZ693t5eSk1NVWpqan1lgkJCeHlAwAAAAAAAAAAAADXxKnTlV7OqVOnZDabNWLECNu2oKAgDRw4UFlZWZKkrKwsBQcH2zq4SdKIESPk7e2tffv2NXud0YSsVqm0tGa5zI/tAAAAgEcgHwMA3BnXMQAAAACAJ+D+F3Aol53012w2S5LCwsLstoeFhdn2mc1mhYaG2u1v1aqVQkJCbGXqUl5ervLycttni8XiqGqjqZw9K7VtW7NeUiIFBjq3PgAAAIAzkY8BAO6M6xgANxcXV/Pf9eudWw8AAAC4uCa8/63NpBK5FJ7DZUdya0ppaWkKCgqyLREREc6uEgAAAAAAAAAAAAAAAACgDi7byc1oNEqSCgoK7LYXFBTY9hmNRhUWFtrtr6ys1JkzZ2xl6pKSkqLi4mLb8uWXXzq49gDgPuLi7Hv6AwAAAAAAAAAAAADcA7/3wlO4bCe3yMhIGY1Gbdu2zbbNYrFo3759MplMkiSTyaSioiJlZ2fbymzfvl3V1dUaOHBgvcf29/eXwWCwWwAAAAAAAAAAAAAAAAAArqeVM09eUlKiEydO2D6fOnVKOTk5CgkJUZcuXTRr1iw99dRT6t69uyIjI/XEE08oPDxcY8eOlST16tVLI0eO1NSpU7VixQpVVFQoKSlJ48ePV3h4uJNaBQAAAAAAXFHtG63r1zu3HgAAAAAAAACAq+PUTm4HDx7U0KFDbZ+Tk5MlSQkJCVq9erUee+wxlZaWatq0aSoqKtKdd96pTZs2qXXr1rbvrF27VklJSRo+fLi8vb0VHx+vZcuWNXtbAAAAAAAAAAAAAAAAAHg2po9tGk7t5DZkyBBZrdZ693t5eSk1NVWpqan1lgkJCVFmZmZTVA8AAAAAAAAAAAAAAAAA4GRO7eQGNJiPj/TLX55fB9BgF/YSZ1omAABaCPIxAMCdcR0DAAAAAHgC7n8Bh6KTG9xD69bSm286uxYAAACAayAfA1fEyx6AC+M6hv+fvTuPs6l+/Dj+nn1jZjLMjGUs2cnWKKayVCJpIirky1RK+qKiRUq2QuobWlB9E9WXtCAtKHzRtxj7ZMuSyDYzQgzDDGY+vz/Oby7X7DN35t6ZeT0fj/Nw7jmfc87nfNy5933P+ZxzAAAAAKAs4Pcv4FB0cgMAAAAAAKXalR3eAAAAAAAAAAAlD53cAKAM4eQeAAAAAAAA4BgcawMAAACA4uPu7AoAeZKcLLm5WUNysrNrAwAAADgX+RgAUJLxPQYAAAAAKAv4/Qs4FJ3cAAAAAAAAAAAAAAAAABcSHc3dg4Er0ckNAIAiQOgEAAAAAAAAAAAAAMAx6OQGAAAAAAAAAAAAAAAAAHBZdHIDAAAAAAAAAAAAAAAAALgsOrkBAAAAAAAAAAAAAAAAAFwWndwAAAAAAAAAAAAAAAAAAC7L09kVAPLEw0O6667L4wAAAEBZRj4GUMJER18e//Zb59UDLoLvMQAAAABAWeCg378cVwEsdHJDyeDrK33/vbNrAQAAALgG8jEAoCTjewwAAAAAUBbw+xdwKB5XCgAAAAAAAAAAAAAAAABwWXRyAwAAAAAAAAAAAAAAAAC4LDq5oWRITpYCAqwhOdnZtQEAAACci3wMACjJ+B4DAAAAAJQF/P4FHMrT2RUA8uzcOWfXAAAAAHAd5GMAQEnG9xgAAAAAoCzg9y/gMNzJDQAAAAAAAAAAAAAAAADgsriTGwAAAAAAAAAAQC6io51dg9Ito32//da59QAAAHBlZFKUZXRyAwAAAAAAZQoHAwEAAAAAAACgZOFxpQAAAAAAAAAAAAAAAAAAl8Wd3ACglOLuFAAAACiLyMGuhf8PAAAAAAAAAI5AJzeUDO7uUrt2l8cBAACAsox8DAAoyfgeAwAAAACUBfz+BRyKTm4oGfz8pFWrnF0LAAAAwDWQjwEAJRnfYwAAAACAsoDfv4BD0VUUAAAAAAAAAAAgBzyCu/hER9PeAAAAADKjkxsAAAAAAAAAAAAAAAAAwGXRyQ0lQ3KyVKmSNSQnO7s2AAAAgHORjwEAJRnfYwBKEO4qBgAAgALj9y/gUHRyQ8lx/Lg1AAAAACAfAwCyNWbMGLm5udkNDRo0sM1PSUnRoEGDFBISonLlyqlHjx5KTEws3kryPQYAAAAAKAvy+PuXiyuA3NHJDQAAAAAAlGgZBwE5EAhc1rhxY8XHx9uGn3/+2TZv6NCh+vbbb/Xll19q9erVOnr0qLp37+7E2gIAAJQdJeKCBAAAABfk6ewKAAAAAAAAAHAsT09PhYeHZ5p++vRpzZw5U3PnztVtt90mSZo1a5YaNmyo2NhYtW7durirCgAAUOY0btxYy5cvt7329Lx8ynbo0KH6/vvv9eWXXyooKEiDBw9W9+7d9csvvzijqgAAoAhkdbHut98Wfz1KGu7kBgAAAAAAAJQye/fuVZUqVXTttdeqT58+OnjwoCRp06ZNunjxojp06GAr26BBA1WvXl1r1651VnUBAADKlIwLEjKGihUrSrp8QcLkyZN12223KTIyUrNmzdKaNWsUGxvr5FoDAAA4F3dyAwAAAAAAAEqRVq1aafbs2apfv77i4+M1duxYtWnTRtu3b1dCQoK8vb0VHBxst0xYWJgSEhJyXG9qaqpSU1Ntr5OSkoqi+gAAAKVexgUJvr6+ioqK0sSJE1W9evVcL0jI7q675DQAAFxfVndvQ/7QyQ0AShm+HAEAAFBWkH2BrHXu3Nk23rRpU7Vq1Uo1atTQF198IT8/vwKvd+LEiRo7dqwjqggAAFBmFcUFCeQ0AABQFvC4UpQM7u5Sy5bW4M7bFgAAVzBmzBi5ubnZDQ0aNLDNT0lJ0aBBgxQSEqJy5cqpR48eSkxMdGKNgVKEfAygFIiOpqNicQkODla9evX0+++/Kzw8XBcuXNCpU6fsyiQmJio8PDzH9YwYMUKnT5+2DYcOHSpYhfgeAwDkAVkBpVXnzp11//33q2nTpurUqZMWL16sU6dO6YsvvijwOh2W0wAAjsXvX8ChuJMbSgY/P2nDBmfXAgAAXKVx48Zavny57bWn5+V4OXToUH3//ff68ssvFRQUpMGDB6t79+765ZdfnFFVoHQhHwMA8uHs2bPat2+f+vbtq8jISHl5eWnFihXq0aOHJGn37t06ePCgoqKiclyPj4+PfHx8Cl8hvscAAABsrrwg4Y477rBdkHDl3dxyuyDBYTkNAOBY/P4FHIquogAAACgwT09PhYeH24aKFStKkk6fPq2ZM2dq8uTJuu222xQZGalZs2ZpzZo1io2NdXKtAQAASrdnn31Wq1ev1oEDB7RmzRrde++98vDwUO/evRUUFKT+/ftr2LBhWrlypTZt2qSHH35YUVFRat26tbOrDgAAUOZkXJBQuXJluwsSMuT1ggQAAIDSjju5AQAAoMD27t2rKlWqyNfXV1FRUZo4caKqV6+uTZs26eLFi+rQoYOtbIMGDVS9enWtXbs22xOoqampSk1Ntb1OSkoq8n0AAAAobQ4fPqzevXvrxIkTqlSpkm655RbFxsaqUqVKkqQpU6bI3d1dPXr0UGpqqjp16qTp06c7udYAAABlw7PPPqvo6GjVqFFDR48e1ejRo7O8IKFChQoKDAzUkCFDuCABAABALn4ntzFjxsjNzc1uaNCggW1+SkqKBg0apJCQEJUrV049evRQYmKiE2uMInPunFSzpjWcO+fs2gBAnkVHXx6A0qZVq1aaPXu2li5dqhkzZmj//v1q06aNzpw5o4SEBHl7e9s9VkGSwsLClJCQkO06J06cqKCgINsQERFRxHsBlFDkY5Rx5CsgZ/PmzdPRo0eVmpqqw4cPa968eapdu7Ztvq+vr6ZNm6aTJ08qOTlZCxYsyPHxVw7H9xgAACjDMi5IqF+/vh544AGFhIRkuiDh7rvvVo8ePdS2bVuFh4drwYIFTq41AKBA+P0LOJTL38mtcePGWr58ue21p+flKg8dOlTff/+9vvzySwUFBWnw4MHq3r27fvnlF2dUFUXJGOnPPy+PA0AJlHEi9ttvnVsPwFE6d+5sG2/atKlatWqlGjVq6IsvvpCfn1+B1jlixAgNGzbM9jopKYmObkBWyMcAgJKM7zEAAFCGzZs3L8f5GRckTJs2rZhqBAAoMvz+BRzK5Tu5eXp6Znkl6enTpzVz5kzNnTtXt912myRp1qxZatiwoWJjY7llLwAAQDELDg5WvXr19Pvvv+uOO+7QhQsXdOrUKbu7uSUmJuZ4lxAfHx/5+PgUQ20BAAAAAEBJwIWjAAAAACQXf1ypJO3du1dVqlTRtddeqz59+ujgwYOSpE2bNunixYvq0KGDrWyDBg1UvXp1rV271lnVBQAAKLPOnj2rffv2qXLlyoqMjJSXl5dWrFhhm797924dPHhQUVFRTqwlAAAAAAC54/HoAAAAAOBaXPpObq1atdLs2bNVv359xcfHa+zYsWrTpo22b9+uhIQEeXt7290ZRJLCwsKUkJCQ43pTU1OVmppqe52UlFQU1QcAACjVnn32WUVHR6tGjRo6evSoRo8eLQ8PD/Xu3VtBQUHq37+/hg0bpgoVKigwMFBDhgxRVFQUd9wFAAAAAAAAAABlHhdVAPnj0p3cOnfubBtv2rSpWrVqpRo1auiLL76Qn59fgdc7ceJEjR071hFVBAAAKLMOHz6s3r1768SJE6pUqZJuueUWxcbGqlKlSpKkKVOmyN3dXT169FBqaqo6deqk6dOnO7nWAAAAAAAAAAAAAEoal+7kdrXg4GDVq1dPv//+u+644w5duHBBp06dsrubW2JiosLDw3Ncz4gRIzRs2DDb66SkJEVERBRVtQGgyNHLH4AzzJs3L8f5vr6+mjZtmqZNm1ZMNQIAACUBv18AAAAAAACyxnETIHslqpPb2bNntW/fPvXt21eRkZHy8vLSihUr1KNHD0nS7t27dfDgQUVFReW4Hh8fH/n4+BRHleEobm5So0aXxwEAAICyjHwMACjJ+B4DAAAAAJQF/P4FHMqlO7k9++yzio6OVo0aNXT06FGNHj1aHh4e6t27t4KCgtS/f38NGzZMFSpUUGBgoIYMGaKoqCi1bt3a2VWHo/n7Szt2OLsWgMuhJz8AAGUU+RgAUJLxPQYAAAAAKAv4/Qs4lEt3cjt8+LB69+6tEydOqFKlSrrlllsUGxurSpUqSZKmTJkid3d39ejRQ6mpqerUqZOmT5/u5FoDAAAAAAAAAAAAAAAAABzFpTu5zZs3L8f5vr6+mjZtmqZNm1ZMNQIAoPAy7sD37bfOrQcAAAAAAADs8eQEAAAAAHBN7s6uAJAn585JjRtbw7lzzq4NADhEdPTlAQCAfCEfAwBKMr7HAAAAAABlAb9/AYdy6Tu5ATbGSDt3Xh4HAAAAyjLyMQCgJON7DABQANHRPBkBAACULPf1MPqK37+Aw9DJDQAAAAAAAAAAAAAAAACc5Mqnf3FxR9Z4XCkAAAAAAAAAAAAAAAAAwGVxJzcAAAAAAAAAAAAAAACgGFx5xy4Aeced3AAAAAAAAAAAQJkSHc3JRQAAAAAoSejkBgAAAAAAAAAAAAAAAABwWTyuFCWDm5tUo8blcQAAAKAsIx8DAEoyvscAAAAAAGWBm5sS/azfv2H8/gUKjU5uKBn8/aUDB5xdC8CpeHwCAACwIR+jDCIPA6UI32MAAAAAgDIg1cNfj95+QJL0rb9z6wKUBnRyAwAAAAAAAAAAZRod6gEAAADAtbk7uwIAAAAAAABXi47mZDMAAAAAAACAsodjo1njTm4oGc6fl9q2tcZ/+kny83NufQAAAABnIh8DKEWuPGD37bfOqweKEd9jAAAAAIAywDvtvF5b8/+/f8/z+xcoLDq5oWRIT5c2brw8DgAAAJRl5GMAQEnG9xgAoJAyOsnTQR4AALgyN5Ouuqf5/Qs4Cp3cAMBFcLtRAAAAIDNyMgAAAAAAAEq6++6TUumhg3ziCQj2+BMCAMCFEFQAAAAAAAAAAAAAALDn7uwKAAAAAAAAAAAAAAAAAACQHTq5AQAAAAAAAAAAAAAAAABcFo8rBQAAAAAAgEuIjrb+/fZb59YDAFB2ZHz3oGTg/wsAAAAou+jkhpKjYkVn1wAoEhyYAQAABUI+RilCxyagDOJ7DEAxI28AAACgKGR1rvfKzHnam9+/gKPQyQ0lQ0CA9Ndfzq4FABQZOjsCAPKFfIwSjBPMAPgeAwA4ytXH1MiYAADAlaR6BugfHfn9CzgKndwAAAAAAAAAAECpdHUnKC40BAAAQEHl9eJNMidQNOjkBgAAAAAAihwH95AfV75fuCMLAAAAAAAAAHdnVwDIk/PnpfbtreH8eWfXBgAAAHAu8jEAoCTjewxAEYqOpnM9AAAAXIN32nlNWNNeE9a0l3cav3+BwuJObigZ0tOl1asvjwMlAHceAAAARYZ8DAAoyfgeA1AM6OgGAAAAZ3Mz6WpycrVtHCiMvD4utzSjkxsAAAAAAAAAAChRrj7BQ6c2AAAAACjdeFwpAAAAAAAAAAAAAAAAAMBlcSc3AABcHI++BQAApRF3W0Fe8SgGAAAAAADgSjiuBTgHndwAwAkIPgAAAEBm5GQAAAAAAAAAQFbo5AYAxYA7DwAAAAAAAACFR6d4AAAAACib6OSGksPf39k1AAAAAFwH+RguJqsTzlzkASBbfI8BAAAAAMqAFA9+/wKOQic3lAwBAVJysrNrAQAAALgG8jEAoCTjewwAAAAAUAakegbo/s78/oVjleWLjenkBgAAAAAAAAAAgBIv44RfWTnJBwAAMnN0HsiqQxEA56CTGwAUI0IQAAAAABTOlb+rOIENAGULx9aQV3R2AwAAQFlSVo6X0ckNJUNKitSjhzU+f77k6+vc+gBAMeDALQAgW+RjuABOHMIV8D4sofgeA5ALjokAAADA2RyRSb3SUjRik/X7d2LkfF304Pcvik9p7PhGJzeUDGlp0uLFl8cBoIziJB4AQBL5GE6T34N7nKCGI/F+KkX4HgMAOAnH1gAAQIbi6ADkbtJ0w7HFtnGgOJTmY2h0cgMAByjNXxQAAAAoW/J7gI8sDFdQGq9MBQAAjkNmBQAAGXLKBWQGlFal5WIPOrkBwP/L60kRwg0AAAAAAACQf6XlxApKDo7lAgAAAKWHu7Mr4CjTpk1TzZo15evrq1atWmn9+vXOrhKAUiA6+vIAACg4shoAAIBrIqcBAAC4LrIaADgG53yB0qFUdHL7/PPPNWzYMI0ePVqbN29Ws2bN1KlTJx07dszZVQMAoMhlFcoJ6nAlZDUAKLmuPABItgBKH3IaAFdD5gCAy8hqAJA7R+VHcihQMpSKx5VOnjxZjz32mB5++GFJ0nvvvafvv/9eH330kV544QUn1w5AcSjMo0azKk+IgavL63uUx4DAFZDVAMB15TVHAyXJ1VmZ93b2yGkAclKYYwq5LXv1/MIci+M4HoDSiqwGoDQrzDEp8h/gWCXpGHGJ7+R24cIFbdq0SSNGjLBNc3d3V4cOHbR27dosl0lNTVVqaqrt9enTpyVJSUlJRVtZFFxy8uXxpCQpLc15dSkjHnjg8vgXX7j+9i9evDx+553521Zey+d3vUBxy+k9yleca8vIIMYYJ9fE8fKb1chpQB6Rj0u0jKybU87NKg9fOS27eVeuM6dpWSHvorS6Mkbk5e/vSg88IF26VDqzmlOPqfE9BpQIGcfbcvocvTpbZEzPWDYjX1w9PQP5A85y9Xszu/e2M46NI+84pnYZx9QAFLWC/J7OkNUyV+bCjI+qnI5b5SarXHnlR+DVObS4uKclK6MaFy8l6aLh9y+cK7ffYFfn5MIoiqxW4ju5HT9+XGlpaQoLC7ObHhYWpl27dmW5zMSJEzV27NhM0yMiIoqkjnCwKlWcXYMyJyiobG8fKA34OyoZzpw5o6BS9p+V36xGTgMKgHxcYuX1Iz+nclfPy6psKftqAfLNUX8XpS2rucwxNb7HAJeXn8/R/E4HnC23PM17t2QobTlN4pgaANdVkI/b3JYpqo9wV/lqsFVjOb9/UXI48u/HkVmtxHdyK4gRI0Zo2LBhttfp6ek6efKkQkJC5ObmVix1SEpKUkREhA4dOqTAwMBi2aYroh0stIOFdrDQDhbawUI7WEp7OxhjdObMGVXhBB85zYXQDhbawUI7XEZbWGgHC+1gKe3tQFa7jKzmOmgHC+1goR0stIOFdrDQDpbS3g7ktMvIaa6DdrDQDhba4TLawkI7WGgHS2lvh6LIaiW+k1vFihXl4eGhxMREu+mJiYkKDw/PchkfHx/5+PjYTQsODi6qKuYoMDCwVL5Z84t2sNAOFtrBQjtYaAcL7WApze1Q2q42zZDfrEZOcz20g4V2sNAOl9EWFtrBQjtYSnM7lMasxjG10oF2sNAOFtrBQjtYaAcL7WApze1QGnOaxDG10oB2sNAOFtrhMtrCQjtYaAdLaW4HR2c1d4euzQm8vb0VGRmpFStW2Kalp6drxYoVioqKcmLNAAAAQFYDAABwTeQ0AAAA10VWAwAAyKzE38lNkoYNG6aYmBi1bNlSN954o6ZOnark5GQ9/PDDzq4aAABAmUdWAwAAcE3kNAAAANdFVgMAALBXKjq59ezZU3/99ZdGjRqlhIQENW/eXEuXLlVYWJizq5YtHx8fjR49OtOtg8sa2sFCO1hoBwvtYKEdLLSDhXYo2UpaVuP9ZqEdLLSDhXa4jLaw0A4W2sFCO5RcJS2nSbzfMtAOFtrBQjtYaAcL7WChHSy0Q8lW0rIa7zcL7WChHSy0w2W0hYV2sNAOFtoh/9yMMcbZlQAAAAAAAAAAAAAAAAAAICvuzq4AAAAAAAAAAAAAAAAAAADZoZMbAAAAAAAAAAAAAAAAAMBl0ckNAAAAAAAAAAAAAAAAAOCy6OQGAAAAAAAAAAAAAAAAAHBZdHJzkGnTpqlmzZry9fVVq1attH79+mzLLliwQC1btlRwcLACAgLUvHlzffrpp3ZlHnroIbm5udkNd955Z1HvRqHlpx2uNG/ePLm5ualbt252040xGjVqlCpXriw/Pz916NBBe/fuLYKaO5aj26EsvB9mz56daR99fX3typTU94Pk+LYoC+8JSTp16pQGDRqkypUry8fHR/Xq1dPixYsLtU5X4Oh2GDNmTKb3Q4MGDYp6NwotP+3Qvn37TPvo5uamLl262MqU5M8IFD2ymoWsZiGrWchqFnKahZxmIadZyGkoTuQ0CznNQk6zkNMuI6tZyGoWspqFrIbiRFazkNUsZDULWc1CTrOQ0yzkNAs5rRgYFNq8efOMt7e3+eijj8yOHTvMY489ZoKDg01iYmKW5VeuXGkWLFhgdu7caX7//XczdepU4+HhYZYuXWorExMTY+68804THx9vG06ePFlcu1Qg+W2HDPv37zdVq1Y1bdq0MV27drWb99prr5mgoCDz9ddfm19//dXcc889platWub8+fNFuCeFUxTtUBbeD7NmzTKBgYF2+5iQkGBXpiS+H4wpmrYoC++J1NRU07JlS3PXXXeZn3/+2ezfv9+sWrXKxMXFFXidrqAo2mH06NGmcePGdu+Hv/76q7h2qUDy2w4nTpyw27/t27cbDw8PM2vWLFuZkvoZgaJHVrOQ1SxkNQtZzUJOs5DTLOQ0CzkNxYmcZiGnWchpFnLaZWQ1C1nNQlazkNVQnMhqFrKahaxmIatZyGkWcpqFnGYhpxUPOrk5wI033mgGDRpke52WlmaqVKliJk6cmOd1tGjRwowcOdL2OiYmJtMXvasrSDtcunTJ3HTTTebDDz/MtM/p6ekmPDzcvPHGG7Zpp06dMj4+Puazzz4rkn1wBEe3gzFl4/0wa9YsExQUlO36Sur7wRjHt4UxZeM9MWPGDHPttdeaCxcuOGydrqAo2mH06NGmWbNmjq5qkSrs/92UKVNM+fLlzdmzZ40xJfszAkWPrGYhq1nIahaymoWcZiGnWchpFnIaihM5zUJOs5DTLOS0y8hqFrKahaxmIauhOJHVLGQ1C1nNQlazkNMs5DQLOc1CTisePK60kC5cuKBNmzapQ4cOtmnu7u7q0KGD1q5dm+vyxhitWLFCu3fvVtu2be3mrVq1SqGhoapfv76eeOIJnThxwuH1d5SCtsO4ceMUGhqq/v37Z5q3f/9+JSQk2K0zKChIrVq1ylPbOkNRtEOGsvB+OHv2rGrUqKGIiAh17dpVO3bssM0rie8HqWjaIkNpf0988803ioqK0qBBgxQWFqbrrrtOEyZMUFpaWoHX6WxF0Q4Z9u7dqypVqujaa69Vnz59dPDgwSLdl8JwxP/dzJkz1atXLwUEBEgquZ8RKHpkNQtZzUJWs5DVLOQ0CznNQk6zkNNQnMhpFnKahZxmIaddRlazkNUsZDULWQ3FiaxmIatZyGoWspqFnGYhp1nIaRZyWvGhk1shHT9+XGlpaQoLC7ObHhYWpoSEhGyXO336tMqVKydvb2916dJF77zzju644w7b/DvvvFOffPKJVqxYoUmTJmn16tXq3Llzpj9sV1GQdvj55581c+ZM/fvf/85yfsZy+W1bZyqKdpDKxvuhfv36+uijj7Ro0SL95z//UXp6um666SYdPnxYUsl8P0hF0xZS2XhP/PHHH/rqq6+UlpamxYsX6+WXX9abb76pV199tcDrdLaiaAdJatWqlWbPnq2lS5dqxowZ2r9/v9q0aaMzZ84U6f4UVGH/79avX6/t27fr0UcftU0rqZ8RKHpkNQtZzUJWs5DVLOQ0CznNQk6zkNNQnMhpFnKahZxmIaddRlazkNUsZDULWQ3FiaxmIatZyGoWspqFnGYhp1nIaRZyWvHxdHYFyqry5csrLi5OZ8+e1YoVKzRs2DBde+21at++vSSpV69etrJNmjRR06ZNVbt2ba1atUq33367k2rtOGfOnFHfvn3173//WxUrVnR2dZwmr+1Q2t8PkhQVFaWoqCjb65tuukkNGzbU+++/r1deecWJNSt+eWmLsvCeSE9PV2hoqD744AN5eHgoMjJSR44c0RtvvKHRo0c7u3rFJi/t0LlzZ1v5pk2bqlWrVqpRo4a++OKLHK+QKqlmzpypJk2a6MYbb3R2VVCKkdXIahJZ7UpkNQs5zUJOs5DTMiOnoTiQ08hpEjntSuS0y8hqFrKahayWGVkNxYGsRlaTyGpXIqtZyGkWcpqFnJYZOS3v6ORWSBUrVpSHh4cSExPtpicmJio8PDzb5dzd3VWnTh1JUvPmzfXbb79p4sSJtpB3tWuvvVYVK1bU77//7pIf4vlth3379unAgQOKjo62TUtPT5ckeXp6avfu3bblEhMTVblyZbt1Nm/evAj2ovCKoh1q166dabnS9n7IipeXl1q0aKHff/9dkkrk+0EqmrbISml8T1SuXFleXl7y8PCwTWvYsKESEhJ04cIFh7RtcSuKdvD29s60THBwsOrVq5fje8aZCvN/l5ycrHnz5mncuHF200vqZwSKHlnNQlazkNUsZDULOc1CTrOQ0yzkNBQncpqFnGYhp1nIaZeR1SxkNQtZzUJWQ3Eiq1nIahaymoWsZiGnWchpFnKahZxWfHhcaSF5e3srMjJSK1assE1LT0/XihUr7Hoj5yY9PV2pqanZzj98+LBOnDhh9+Z1JflthwYNGmjbtm2Ki4uzDffcc49uvfVWxcXFKSIiQrVq1VJ4eLjdOpOSkrRu3bp8tW1xKop2yEppez9kJS0tTdu2bbPtY0l8P0hF0xZZKY3viZtvvlm///677YePJO3Zs0eVK1eWt7e3wz5/i1NRtENWzp49q3379pWq90OGL7/8UqmpqfrHP/5hN72kfkag6JHVLGQ1C1nNQlazkNMs5DQLOc1CTkNxIqdZyGkWcpqFnHYZWc1CVrOQ1SxkNRQnspqFrGYhq1nIahZymoWcZiGnWchpxcig0ObNm2d8fHzM7Nmzzc6dO82AAQNMcHCwSUhIMMYY07dvX/PCCy/Yyk+YMMH8+OOPZt++fWbnzp3mX//6l/H09DT//ve/jTHGnDlzxjz77LNm7dq1Zv/+/Wb58uXm+uuvN3Xr1jUpKSlO2ce8yG87XC0mJsZ07drVbtprr71mgoODzaJFi8zWrVtN165dTa1atcz58+eLclcKxdHtUFbeD2PHjjU//PCD2bdvn9m0aZPp1auX8fX1NTt27LCVKYnvB2Mc3xZl5T1x8OBBU758eTN48GCze/du891335nQ0FDz6quv5nmdrqgo2uGZZ54xq1atMvv37ze//PKL6dChg6lYsaI5duxYse9fXhX0s/KWW24xPXv2zHKdJfUzAkWPrGYhq1nIahaymoWcZiGnWchpFnIaihM5zUJOs5DTLOS0y8hqFrKahaxmIauhOJHVLGQ1C1nNQlazkNMs5DQLOc1CTisedHJzkHfeecdUr17deHt7mxtvvNHExsba5rVr187ExMTYXr/00kumTp06xtfX11xzzTUmKirKzJs3zzb/3LlzpmPHjqZSpUrGy8vL1KhRwzz22GMu/cGVIT/tcLWsQl56erp5+eWXTVhYmPHx8TG333672b17dxHV3nEc2Q5l5f3w9NNP28qGhYWZu+66y2zevNlufSX1/WCMY9uirLwnjDFmzZo1plWrVsbHx8dce+21Zvz48ebSpUt5XqercnQ79OzZ01SuXNl4e3ubqlWrmp49e5rff/+9uHanwPLbDrt27TKSzI8//pjl+kryZwSKHlnNQlazkNUsZDULOc1CTrOQ0yzkNBQncpqFnGYhp1nIaZeR1SxkNQtZzUJWQ3Eiq1nIahaymoWsZiGnWchpFnKahZxW9NyMMca595IDAAAAAAAAAAAAAAAAACBr7s6uAAAAAAAAAAAAAAAAAAAA2aGTGwAAAAAAAAAAAAAAAADAZdHJDQAAAAAAAAAAAAAAAADgsujkBgAAAAAAAAAAAAAAAABwWXRyAwAAAAAAAAAAAAAAAAC4LDq5AQAAAAAAAAAAAAAAAABcFp3cAAAAAAAAAAAAAAAAAAAui05uAAolISFBd9xxhwICAhQcHJzttKIwe/bsIl1/WeLm5qavv/46z+Vr1qypqVOnFll9AACAY5DVSgeyGgAApQ85rXQgpwEAUDqR1UoHshpQ+tDJDUC2HnroIbm5uWUa7rzzTluZKVOmKD4+XnFxcdqzZ0+20worq1DRs2dPh60/J8YYffDBB2rVqpXKlSun4OBgtWzZUlOnTtW5c+eKfPuONGbMGDVv3jzT9Pj4eHXu3DnP69mwYYMGDBhge53fkAgAAAqPrGYhq2VGVgMAwLnIaRZyWmbkNAAAnI+sZiGrZUZWA1yfp7MrAMC13XnnnZo1a5bdNB8fH9v4vn37FBkZqbp16+Y4rSj4+fnJz8+vSLchSX379tWCBQs0cuRIvfvuu6pUqZJ+/fVXTZ06VTVr1lS3bt2KvA5FLTw8PF/lK1WqVEQ1AQAA+UFWI6tlhawGAIDzkdPIaVkhpwEA4BrIamS1rJDVgBLAAEA2YmJiTNeuXbOdX6NGDSPJNsTExGQ5zRhj/v77b9O/f39TsWJFU758eXPrrbeauLg4u/V98803pmXLlsbHx8eEhISYbt26GWOMadeund06Mz66Zs2aZYKCgowxxuzevdtIMr/99pvdOidPnmyuvfZa2+tt27aZO++80wQEBJjQ0FDzj3/8w/z111/Z7uPnn39uJJmvv/4607z09HRz6tQpY4wxaWlpZuzYsaZq1arG29vbNGvWzCxZssRWdv/+/UaSmT9/vmnfvr3x8/MzTZs2NWvWrLGVydifpUuXmgYNGpiAgADTqVMnc/ToUbvt/vvf/zYNGjQwPj4+pn79+mbatGl28w8dOmR69eplrrnmGuPv728iIyNNbGysmTVrVqZ2nDVrljHGGElm4cKFxhhjoqKizPPPP2+3zmPHjhlPT0+zevVqY4z1fz9lyhTb+JXrrFGjhtm/f79xc3MzGzZssFvPlClTTPXq1U1aWlq2bQ4AAPKGrEZWy0BWAwDAtZDTyGkZyGkAALgeshpZLQNZDSh56OQGIFu5hbxjx46ZO++80zzwwAMmPj7enDp1KstpxhjToUMHEx0dbTZs2GD27NljnnnmGRMSEmJOnDhhjDHmu+++Mx4eHmbUqFFm586dJi4uzkyYMMEYY8yJEydMtWrVzLhx40x8fLyJj483xtiHPGOMadmypRk5cqRdHSMjI23T/v77b1OpUiUzYsQI89tvv5nNmzebO+64w9x6663Z7uM999xj6tevn2tbTZ482QQGBprPPvvM7Nq1yzz//PPGy8vL7NmzxxhzOeQ1aNDAfPfdd2b37t3mvvvuMzVq1DAXL1607Y+Xl5fp0KGD2bBhg9m0aZNp2LChefDBB23b+c9//mMqV65s5s+fb/744w8zf/58U6FCBTN79mxjjDFnzpwx1157rWnTpo353//+Z/bu3Ws+//xzs2bNGnPu3DnzzDPPmMaNG9va8dy5c8YY+5D37rvvmurVq5v09HTbdt955x27aVeGvGPHjtkCY3x8vDl27Jgxxpg77rjD/POf/7Rrp6ZNm5pRo0bl2p4AACB3ZDWyWgayGgAAroWcRk7LQE4DAMD1kNXIahnIakDJQyc3ANmKiYkxHh4eJiAgwG4YP368rUzXrl1tVytkN+1///ufCQwMNCkpKXblateubd5//31jjNV7vk+fPtnW5cpQkeHqkDdlyhRTu3Zt2+urr2545ZVXTMeOHe3WcejQISPJ7N69O8vtNmzY0Nxzzz3Z1itDlSpV7NrFGGNuuOEGW8jJCHkffvihbf6OHTvs6pdxpcHvv/9uKzNt2jQTFhZme127dm0zd+5cu+288sorJioqyhhjzPvvv2/Kly9vC89XGz16tGnWrFmm6VeGvIyrFn766Sfb/KioKDN8+HDb66v/P65cPsPnn39urrnmGtv/+6ZNm4ybm5vZv39/lnUDAAD5Q1Yjq2UgqwEA4FrIaeS0DOQ0AABcD1mNrJaBrAaUPO4CgBzceuutiouLsxsGDhyYr3X8+uuvOnv2rEJCQlSuXDnbsH//fu3bt0+SFBcXp9tvv71Qde3Vq5cOHDig2NhYSdKcOXN0/fXXq0GDBrZ6rFy50q4OGfMy6nE1Y0yu201KStLRo0d18803202/+eab9dtvv9lNa9q0qW28cuXKkqRjx47Zpvn7+6t27dp2ZTLmJycna9++ferfv7/dPrz66qt27diiRQtVqFAh13pnp1KlSurYsaPmzJkjSdq/f7/Wrl2rPn365Gs93bp1k4eHhxYuXChJmj17tm699VbVrFmzwHUDAAD2yGpkNbIaAACuiZxGTiOnAQDgushqZDWyGlAyeTq7AgBcW0BAgOrUqVOodZw9e1aVK1fWqlWrMs0LDg6WJPn5+RVqG5IUHh6u2267TXPnzlXr1q01d+5cPfHEE3b1iI6O1qRJkzItmxG4rlavXj3t2rWr0HXL4OXlZRt3c3OTJKWnp2c5P6NMRtA8e/asJOnf//63WrVqZVfOw8NDkmPaUZL69OmjJ598Uu+8847mzp2rJk2aqEmTJvlah7e3t/r166dZs2ape/fumjt3rt566y2H1A8AAFjIamQ1shoAAK6JnEZOI6cBAOC6yGpkNbIaUDJxJzcARe76669XQkKCPD09VadOHbuhYsWKkqwe/itWrMh2Hd7e3kpLS8t1W3369NHnn3+utWvX6o8//lCvXr3s6rFjxw7VrFkzUz0CAgKyXN+DDz6oPXv2aNGiRZnmGWN0+vRpBQYGqkqVKvrll1/s5v/yyy9q1KhRrnXOq7CwMFWpUkV//PFHpvrXqlVLktWOcXFxOnnyZJbryGs7du3aVSkpKVq6dKnmzp2b61UMXl5eWa730Ucf1fLlyzV9+nRdunRJ3bt3z8OeAgCA4kRWcwyyGgAAcDRymmOQ0wAAQFEgqzkGWQ1AftDJDUCOUlNTlZCQYDccP348X+vo0KGDoqKi1K1bN/344486cOCA1qxZo5deekkbN26UJI0ePVqfffaZRo8erd9++03btm2zu+KgZs2a+umnn3TkyJEct9+9e3edOXNGTzzxhG699VZVqVLFNm/QoEE6efKkevfurQ0bNmjfvn364Ycf9PDDD2cbfB544AH17NlTvXv31oQJE7Rx40b9+eef+u6779ShQwetXLlSkvTcc89p0qRJ+vzzz7V792698MILiouL01NPPZWvtsrN2LFjNXHiRL399tvas2ePtm3bplmzZmny5MmSpN69eys8PFzdunXTL7/8oj/++EPz58/X2rVrJVntuH//fsXFxen48eNKTU3NcjsBAQHq1q2bXn75Zf3222/q3bt3jvWqWbOmVqxYoYSEBP3999+26Q0bNlTr1q01fPhw9e7d22FXWgAAAAtZjaxGVgMAwDWR08hp5DQAAFwXWY2sRlYDSigDANmIiYkxkjIN9evXt5Xp2rWriYmJsVsuq2lJSUlmyJAhpkqVKsbLy8tERESYPn36mIMHD9rKzJ8/3zRv3tx4e3ubihUrmu7du9vmrV271jRt2tT4+PiYjI+uWbNmmaCgoEz1fuCBB4wk89FHH2Wat2fPHnPvvfea4OBg4+fnZxo0aGCefvppk56enm07pKWlmRkzZpgbbrjB+Pv7m8DAQBMZGWneeustc+7cOVuZMWPGmKpVqxovLy/TrFkzs2TJEts69u/fbySZLVu22Kb9/fffRpJZuXJltvuzcOFCc/VH9Zw5c2ztdM0115i2bduaBQsW2OYfOHDA9OjRwwQGBhp/f3/TsmVLs27dOmOMMSkpKaZHjx4mODjYSDKzZs0yxhgjySxcuNBuO4sXLzaSTNu2bTO1SY0aNcyUKVNsr7/55htTp04d4+npaWrUqGFXdubMmUaSWb9+fXZNDAAACoCsZiGrkdUAAHA15DQLOY2cBgCAKyKrWchqZDWgJHIz5v8fdgwAQBF45ZVX9OWXX2rr1q3OrgoAAACuQlYDAABwTeQ0AAAA10VWA5yDx5UCAIrE2bNntX37dr377rsaMmSIs6sDAACAK5DVAAAAXBM5DQAAwHWR1QDnopMbAKBIDB48WJGRkWrfvr0eeeQRZ1cHAAAAVyCrAQAAuCZyGgAAgOsiqwHOxeNKAQAAAAAAAAAAAAAAAAAuizu5AQAAAAAAAAAAAAAAAABcFp3cAAAAAAAAAAAAAAAAAAAui05uAAAAAAAAAAAAAAAAAACXRSc3AAAAAAAAAAAAAAAAAIDLopMbAAAAAAAAAAAAAAAAAMBl0ckNAAAAAAAAAAAAAAAAAOCy6OQGAAAAAAAAAAAAAAAAAHBZdHIDAAAAAAAAAAAAAAAAALgsOrkBAAAAAAAAAAAAAAAAAFwWndwAAAAAAAAAAAAAAAAAAC6LTm4AAAAAAAAAAAAAAAAAAJdFJzcAAAAAAAAAAAAAAAAAgMuikxsAAAAAAAAAAAAAAAAAwGXRyQ0AAAAAAAAAAAAAAAAA4LLo5AagRLlw4YI+++wz9evXTw0aNFBISIi8vLxUsWJFRUZG6oknntDy5cuVnp6e67qWLFmiAQMGqFGjRqpQoYJ8fX0VERGhW2+9Va+//rqOHj2a6zoOHDggNze3fA3dunVzQEtY0tPTtXPnTs2ePVv//Oc/dcMNN8jHx8e2rVWrVjlsWwAAADkhp9k7d+6cFixYoCeeeEI33HCDrrnmGnl5eSkkJERRUVEaM2aMEhISHLY9AABQdq1atcou05QvX17nzp3Ldbnz588rKCjIbtmrjyUV5bpzM3z48AItv2TJEt17772qVq2afHx8VK1aNd17771asmRJrsumpqYqNjZW77zzjvr27av69evL3d3dVgcAAAAAgPN4OrsCAJBXCxYs0DPPPKMDBw5kmnfixAmdOHFCmzdv1nvvvad69epp8uTJ6tKlS6ayO3bs0GOPPaa1a9dmmnf48GEdPnxYq1at0rhx4zRixAi9+OKLLnsQ69NPP9VDDz3k7GoAAIAyjpxmb+vWrbr55pt19uzZTPNOnjyp2NhYxcbGasqUKfrggw/Us2dPJ9QSAACUVmfPntXXX3+tBx98MMdyixYtUlJSksus+0pxcXGaPHlyvpZJT0/XgAEDNHPmTLvpR44c0ZEjR/T111/r0Ucf1fvvvy9396yv/x84cKBmz55d0GoDAAAAAIoQndwAlAivvPKKRo0aZXt9xx136J577lGjRo0UHByskydPavfu3fr222+1bNky7dmzRy+99FKmk6f/+9//dM899+jUqVOSpMjISMXExKhp06YqV66cjhw5oqVLl+rjjz9WcnKyRo4cqe3bt+uTTz6Rl5dXjnXs2rWrXn311Vz3JTAwMP8NkA1jjG3cy8tLTZo00cWLF7Vt2zaHbQMAACAn5LTMkpKSbB3cbr75Zt19991q2bKlQkJC9Ndff2nBggX697//raSkJPXp00eBgYHq3LmzQ7YNAADKNl9fX6WkpOjTTz/NtSPap59+areMM9d9pYzOapcuXVJoaKiOHTuWp+VeeuklWwe3Fi1a6Pnnn1ft2rW1b98+vf7669qyZYs+/PBDVapUSRMmTMhyHVceaytfvryuv/567d69mzvwAgAAAIALcDNX/moDABc0a9YsPfLII5Kk0NBQffHFF2rXrl225bdv366hQ4fqr7/+UlxcnG364cOH1axZM508eVJubm56/fXX9cwzz2R594/9+/erW7du2rp1qyTp+eef16RJkzKVO3DggGrVqiVJiomJKfYrPdevX69169bphhtuUPPmzeXr66sxY8Zo7NixkqSVK1eqffv2xVonAABQdpDTsrZmzRq99dZbGj16tBo1apRlmUWLFunee++VMUa1a9fW3r17XfKudAAAwPWtWrVKt956qyTpgQce0BdffCEPDw8dPnxY4eHhWS5z7NgxVa1aVZcuXVLPnj31+eefS8p8LKko152dqVOnaujQoWrQoIHuvfdeTZw4Mdfl9+zZo8aNG+vSpUtq2bKlfvrpJ/n5+dnmnzt3Tu3atdPGjRvl6emp3377TXXq1Mm0ns8//1znz5/XDTfcoIYNG8rd3V3t27fX6tWrJdl3ggMAAAAAFK+s78kNAC7iyJEjGjx4sCQpICBAq1evzvHEqSRdd911+uGHH/Tss8/aTR8wYIBOnjwpybrjyLPPPpvticRatWpp2bJlqlKliiTpjTfe0Lp16wq7Ow534403asiQIWrdurV8fX2dXR0AAFCGkNOyd9NNN+nzzz/PtoObZN1drnv37pKkffv2acuWLcVVPQAAUIp17NhR4eHhSktL02effZZtuc8++0yXLl1SeHi47rjjDqevO8PBgwf18ssvS5Lee+89eXt752m5qVOn6tKlS5Kkd955x66DmyT5+/vrnXfekSRdunRJU6ZMyXI9PXv21EMPPaTGjRtn+0hTAAAAAIBz8CsNgEubMmWKzp07J0kaN26cGjRokKfl3N3d9Y9//MP2+tdff9WSJUskSU2aNNELL7yQ6zpCQ0M1efJkSdZVmq+//np+qw8AAFBqkdMKL+OuKJLV0Q0AAKCwPDw81Lt3b0mXHxmalU8++USS9OCDD8rDw8Pp684waNAgnT17VjExMbleQJHBGKNFixZJkho0aKDWrVtnWa5169aqX7++JOuuutyVDQAAAABKFjq5AXBZxhh9/PHHkqy7gzz22GMFXlfGeiRp8ODBeT7Adt9996lq1aqSpK+//lp///13gesAAABQWpDTHCM1NdU2nt8TwAAAANnp27evJGnLli3asWNHpvk7d+7U5s2b7cq6wrq/+OILfffdd6pQoYL+9a9/5Xm5/fv36+jRo5KUa8e4jPlHjhzRgQMH8lU/AAAAAIBz0ckNgMvasWOHjh8/Lklq06aNypcvX+B1/fTTT7bx6OjoPC/n4eGhLl26SJLS09O1Zs2aAtcBAACgtCCnOcbq1att4w0bNnRiTQAAQGnSokULNW7cWFLWd1zLmHbdddepefPmLrHuU6dO6amnnpIkTZo0SRUrVszzsjt37rSN53Z34Svn//bbb3neBgAAAADA+TydXQEAyM6vv/5qG4+MjCzUurZu3SpJCg8PV+XKlfO17PXXX29Xp4yTqVc7deqUtm/fnuv6atWqpYCAgHzVAQAAwJWQ0wrv119/1ffffy/JekwrndwAAIAj9evXT8OHD9fcuXM1ceJEubm5SbLuyDtnzhxbGVdZ9/PPP6+EhATdfPPN6t+/f76WPXz4sG28WrVqOZaNiIiwjR86dChf2wEAAAAAOBed3AC4rBMnTtjGQ0NDC7ye06dP6+LFi5Ksk6f5FRYWlmWdrrZo0SItWrQo1/WtXLlS7du3z3c9AAAAXAU5rXBSU1P16KOPKi0tTZI0fvz4It8mAAAoW/r06aMRI0bo0KFDWrVqlW699VZJ0qpVq3To0CG5u7vrwQcfdIl1/+9//9OHH34oT09Pvffee7ZOc3l15swZ23i5cuVyLHvlBQ1nz57N13YAAAAAAM7F40oBuKwrD1AV5o4a+TnQlZUrl0lKSipwPQAAAEoLclrhDB48WBs3bpQkxcTE5OsxrQAAAHlRtWpVW+ezKx8rmjF+2223qWrVqk5f94ULFzRgwAAZYzR06FBdd911+a5PSkqKbdzb2zvHsj4+Prbx8+fP53tbAAAAAADnoZMbAJdVvnx523hycrJD1lOQKzSvXCYwMDDbcjExMTLG5DpwFzcAAFDSkdMKbuLEifrwww8lSTfccIOmTZtW5NsEAABlU8YjQ+fPn6/z58/r/Pnz+uqrr+zmOXvdEyZM0K5du1S9enWNHj26QHXx9fW1jV+4cCHHsqmpqbZxPz+/Am0PAAAAAOAcdHID4LJCQkJs44mJiQVeT2BgoDw9raczJyQk5Hv5K7d9ZZ0AAADKKnJawbz//vt68cUXJUkNGjTQ4sWLC3UnPAAAgJx0795d/v7+SkpK0qJFi/T111/rzJkzCggIUPfu3Z2+7l27dmnixImSpHfeeafAuSg/F05ceYFGQe4kDAAAAABwHk9nVwAAstOsWTPb+ObNmwu8Hjc3NzVt2lSbN29WQkKCEhISFB4enuflr9z2lXUCAAAoq8hp+ffZZ5/pn//8pySpRo0aWrZsmSpWrOjkWgEAgNKsXLlyuvfeezVnzhx9+umnMsZIku69995Cd7R3xLqnTJmiCxcu6Nprr9W5c+c0b968TGW2b99uG//vf/9ruzAiOjratp1q1arZyhw+fDjHbR46dMg2HhERkad6AgAAAABcA53cALisxo0bq2LFijp+/Lj+97//KSkpKcfHUOWkbdu2tpOg33zzjQYMGJCn5dLT07V48WJJkru7u26++eYCbR8AAKA0IaflzzfffKN+/fopPT1dlStX1ooVK+xOxgIAABSVfv36ac6cOfrxxx/tprnCujMeHfrHH3+od+/euZZ/5ZVXbOP79++3dXJr1KiRbfquXbtyXMeV8xs2bJjnugIAAAAAnI/HlQJwWW5uboqJiZFkPUrgww8/LPC6HnroIdv4tGnTlJaWlqfl5s+fb7sCtFu3bgoODi5wHQAAAEoLclrerVixQg888IAuXbqkkJAQLVu2TLVr13Z2tQAAQBlx++23q3Llyrp06ZIuXbqkKlWq6Pbbb3f5dedHrVq1VKVKFUnS6tWrcyz7008/SZKqVq2qmjVrFnXVAAAAAAAORCc3AC5t6NCh8vf3lySNGjUq16sxM6Snp2vOnDm2182aNVOnTp0kSVu3btUbb7yR6zqOHz+uYcOGSbJO5D7//PP5rT4AAECpRU7L3Zo1a9S1a1elpqYqKChIP/zwgxo3buzsagEAgDLEw8NDffv2lY+Pj3x8fNS3b1+5uzvmtEBh1z179mwZY3IcRo8ebSu/cuVK2/QrO6i5ubmpa9eukqw7tcXGxma5vdjYWFtm7dq1q9zc3Aqw1wAAAAAAZ6GTGwCXVrVqVb377ruSrLuEtGvXLtcrMnfu3Kk777wz0wnSDz74wHaHjxdffFFTp06VMSbLdfz555/q0KGD7e4gzz33nFq1alXIvQEAACg9yGk5i4uLU5cuXZScnKyAgAB9//33ioyMdHa1AABAGTRp0iSlpKQoJSVFr732WolZd348/fTT8vDwkCQNGTJE58+ft5t//vx5DRkyRJLk6empp59+urirCAAAAAAoJE9nVwAAcvPwww/r8OHDGjVqlI4dO6b27durY8eO6tq1qxo2bKjg4GCdPHlSe/bs0ffff6+lS5cqLS1NzZo1s1tP9erVtXDhQnXt2lVJSUkaOnSo5syZo5iYGDVt2lQBAQE6evSoli5dqo8//ljJycmSpJ49e+rVV1/NtZ6nTp3S9u3bcy3n4eGhhg0bFqwxsjB79my713FxcbbxpUuX6sCBA7bXderU0S233OKwbQMAgLKNnJa1ffv2qVOnTjp16pQk6dVXX1VQUFCOdQgNDVVoaGihtw0AAFAW1atXT88995xee+01bdy4UTfffLOGDx+u2rVra9++fZo0aZK2bNkiybpIom7dulmuJyEhQUuXLs00LcPVx+FuueUW1alTx7E7AwAAAADIEp3cAJQIL7/8sho3bqxnnnlGBw4c0I8//qgff/wx2/KNGzfW66+/nml6+/bt9fPPP+uxxx7TunXrtHHjRm3cuDHLdfj7++uFF17QyJEj8/T4gkWLFmnRokW5lgsKCrKd8HSEhx9+ONt5kyZNsnsdExNDJzcAAOBQ5LTM/ve//+nYsWO210OHDs11mdGjR2vMmDGF3jYAAEBZNX78eB07dkwfffSRtmzZol69emUq079//xwvkti1a1eOx9qunjdr1iw6uQEAAABAMaGTG4ASo3v37rr77rv11VdfacmSJdqwYYOOHTumM2fOKDAwUDVr1lTr1q113333qX379tme8GzSpIliY2P1/fffa+HChfrll18UHx+v8+fPq2LFiqpbt646d+6svn37qkqVKsW8lwAAACUPOQ0AAADO5u7urpkzZ6pHjx764IMPtGHDBh0/flwVK1bUDTfcoMcff1ydO3d2djUBAAAAAAXkZowxzq4EAAAAAAAAAAAAAAAAAABZcXd2BQAAAAAAAAAAAAAAAAAAyA6d3AAAAAAAAAAAAAAAAAAALotObgAAAAAAAAAAAAAAAAAAl+Xp7AoAQFl17NgxHTt2LN/LeXt7q169ekVQIwAAAEjkNAAAAACA4/z000964403tGnTJsXHx2vhwoXq1q1bjsusWrVKw4YN044dOxQREaGRI0fqoYceKpb6AgAAuCo6uQGAk0yfPl1jx47N93I1atTQgQMHHF8hAAAASCKnAXB9M2bM0IwZM2yfOY0bN9aoUaPUuXNnSVL79u21evVqu2Uef/xxvffee7bXBw8e1BNPPKGVK1eqXLlyiomJ0cSJE+XpyeFCAAAAR0pOTlazZs30yCOPqHv37rmW379/v7p06aKBAwdqzpw5WrFihR599FFVrlxZnTp1KoYaAwAAuCaOWgEAAAAAAAAlSLVq1fTaa6+pbt26Msbo448/VteuXbVlyxY1btxYkvTYY49p3LhxtmX8/f1t42lpaerSpYvCw8O1Zs0axcfHq1+/fvLy8tKECROKfX8AAABKs86dO9suRsiL9957T7Vq1dKbb74pSWrYsKF+/vlnTZkyhU5uAACgTHMzxhhnbdxVrjpNT0/X0aNHVb58ebm5uRV+xwAAAPLBGKMzZ86oSpUqcnd3d3Z1XAo5DQAAOFtJyWoVKlTQG2+8of79+6t9+/Zq3ry5pk6dmmXZJUuW6O6779bRo0cVFhYmyTqZOnz4cP3111/y9vbO0zbJagAAwJlKSk67kpubW66PK23btq2uv/56uyw3a9YsPf300zp9+nSWy6Smpio1NdX2Oj09XSdPnlRISAg5DQAAOEVRZDWn3snNVa46PXr0qCIiIhy3YwAAAAVw6NAhVatWzdnVcCnkNAAA4CpcNaulpaXpyy+/VHJysqKiomzT58yZo//85z8KDw9XdHS0Xn75ZdtxtbVr16pJkya2Dm6S1KlTJz3xxBPasWOHWrRokeW2rj55euTIETVq1KiI9gwAACBvXDWnFVRCQoJdTpOksLAwJSUl6fz58/Lz88u0zMSJEzV27NjiqiIAAECeOTKrObWTW3R0tN3r8ePHa8aMGYqNjbV1cvP391d4eHiWy//444/auXOnli9frrCwMDVv3lyvvPKKhg8frjFjxuT5qtPy5ctLsho2MDCwEHsEAEA+JSdLVapY40ePSgEBzq0PnCIpKUkRERG2TILLyGkAkAXyA1CsXDWrbdu2TVFRUUpJSVG5cuW0cOFCW4ezBx98UDVq1FCVKlW0detWDR8+XLt379aCBQskZX/iNGNedrI7eUpWcyA+4wEAyDNXzWnOMGLECA0bNsz2+vTp06pevTo5DQAAOE1RZDWndnK7kjOvOj1z5owkKTAwkKAHACheHh6XxwMDOYFRxvHogMwy2oScBgBXID8ATuFqWa1+/fqKi4vT6dOn9dVXXykmJkarV69Wo0aNNGDAAFu5Jk2aqHLlyrr99tu1b98+1a5du8DbvPrkacbBSrKaA/EZDwBAvrlaTius8PBwJSYm2k1LTExUYGBglndxkyQfHx/5+Phkmk5OAwAAzubIrOb0Tm6udNUpAAAAAAAAUBJ4e3urTp06kqTIyEht2LBBb731lt5///1MZVu1aiVJ+v3331W7dm2Fh4dr/fr1dmUyTqRm90QFKfuTpwAAAHCcqKgoLV682G7asmXL7G4SAgAAUBa5O7sCGVedrlu3Tk888YRiYmK0c+dOSdKAAQPUqVMnNWnSRH369NEnn3yihQsXat++fYXa5ogRI3T69GnbcOjQIUfsCgAAAAAAAOAU6enpdk8uuFJcXJwkqXLlypKsE6fbtm3TsWPHbGWWLVumwMBA28WnAAAAcIyzZ88qLi7Olsn279+vuLg4HTx4UJJ13rJfv3628gMHDtQff/yh559/Xrt27dL06dP1xRdfaOjQoc6oPgAAgMtw+p3cuOoUAAAAAAAAyLsRI0aoc+fOql69us6cOaO5c+dq1apV+uGHH7Rv3z7NnTtXd911l0JCQrR161YNHTpUbdu2VdOmTSVJHTt2VKNGjdS3b1+9/vrrSkhI0MiRIzVo0CCOmQEAADjYxo0bdeutt9peZzz+PSYmRrNnz1Z8fLytw5sk1apVS99//72GDh2qt956S9WqVdOHH36oTp06FXvdAQAAXInTO7ldLb9XnY4fP17Hjh1TaGioJK46BQAAAAAAQOl27Ngx9evXT/Hx8QoKClLTpk31ww8/6I477tChQ4e0fPlyTZ06VcnJyYqIiFCPHj00cuRI2/IeHh767rvv9MQTTygqKkoBAQGKiYnRuHHjnLhXAAAApVP79u1ljMl2/uzZs7NcZsuWLUVYKwAAgJLHqZ3cuOoUAFDmeXpK//zn5XEAAIDckB+AMm/mzJnZzouIiNDq1atzXUeNGjW0ePFiR1YLjsBnPAAAAAAAQJaceqSEq04BoOilpaXp4sWLzq4GcvLmm9a/xkgpKc6tCxzOy8tLHh4ezq4GAMBFFTirkR+AQvP09JSHh4fc3NycXRXgMh8fado0Z9cCgDimBjgbx9QAAABwNad2cuOqUwAoOsYYJSQk6NSpU86uClDmBQcHKzw8nBOoAAAbshrgGjw8PBQaGqqgoCCyGgBAEjkNcCUcUwMAAMCVuOc9AJRSGQfjQkND5e/vz4EAV2WMdOmSNe7pKfH/VKoYY3Tu3DkdO3ZMklS5cmUn1wgA4CoKldXID0ChGWN06dIlJSUlKT4+XufPnyerwTUYIx0/bo1XrMhnPOAEHFMDnI9jagAAAMgKndwAoBRKS0uzHYwLCQlxdnWQk7Q0accOa7xFC4lb8Jc6fn5+kqzHtIeGhvKYBQBA4bMa+QFwmPLly8vHx0fHjx8nq8E1nDsnhYZa42fPSgEBzq0PUMZwTA1wHRxTAwAAwNXcnV0BAIDjXbx4UZLk7+/v5JoAkC7/LWb8bQIAyjayGuBaAgICZIwhqwEAyGmAi+GYGgAAAK5EJzcAKMV4nALgGvhbBABkhe8HwDXwtwgAuBrfDYBr4G8RAAAAV6KTGwAAAAAAAAAAAAAAAADAZdHJDQAAAAAAAAAAAAAAAADgsujkBgAAAAAAAAAAAAAAAABwWXRyAwCgDJo9e7bc3Nx04MABZ1cFAAAAVyGrAQAAuCZyGgAAAOA8dHIDAJQ4GQeTMgZfX1/Vq1dPgwcPVmJiorOrl6M1a9ZozJgxOnXqlDXBzU0KCbEGN7dM5a/eV09PT1WtWlUPPfSQjhw5UryVz8UPP/wgNzc3/ec//7GbfvbsWd19993y8PDQ22+/7fDtpqamavjw4apSpYr8/PzUqlUrLVu2LF/r2Lx5s+655x5VqFBB/v7+uu6663Ks6/jx4+Xm5qbrrruusNUHACD/cskPzlaqslouyGq5K0xWW7VqlV37XjnExsbald27d6969eqlatWqyd/fXw0aNNC4ceN07tw5h+8TUKQ8PaWYGGvw9HR2bQCUMuQ0ctqVCpPTduzYofvvv1/XXnut/P39VbFiRbVt21bffvttprKbNm3SnXfeqcDAQJUvX14dO3ZUXFycg/cGAAAAZQFHSgAAJda4ceNUq1YtpaSk6Oeff9aMGTO0ePFibd++Xf7+/s6uXpbWrFmjsWPH6qGHHlJwcLDk7i7VqpXrclfua2xsrGbPnq2VK3/W999vl4+Pr+rWLfq65+bXX3+VJDVr1sw27ciRI7r77ru1d+9eLVy4UPfcc4/Dt/vQQw/pq6++0tNPP626detq9uzZuuuuu7Ry5UrdcsstuS7/448/Kjo6Wi1atNDLL7+scuXKad++fTp8+HCW5Q8fPqwJEyYoICDA0bsCAEDe5DE/OJsrZLW9e61/85qVMmW1PMoqq/3888/avn27fH1981/xIlBSs5okPfnkk7rhhhvsptWpU8c2fujQId14440KCgrS4MGDVaFCBa1du1ajR4/Wpk2btGjRIofuE1CkfHyk2bOdXQugRImOtv7Nom8NsuEKOS2/yGmuldP+/PNPnTlzRjExMapSpYrOnTun+fPn65577tH777+vAQMGSLIuLL3lllsUERGh0aNHKz09XdOnT1e7du20fv161a9f3+H7BQAAgNKLTm4AgBKrc+fOatmypSTp0UcfVUhIiCZPnqxFixapd+/ehVp3cnKyS3ViunpfK1asqEmTJmnFim90110POLl2lq1bt8rb21sNGjSQZB2g69Kli9LT07V69WpFRkY6fJvr16/XvHnz9MYbb+jZZ5+VJPXr10/XXXednn/+ea1ZsybH5ZOSktSvXz916dJFX331ldzdc7/J7bPPPqvWrVsrLS1Nx48fd8h+AABQGpHVJumbb77RAw+Q1Qqa1TK0adNG9913X7bzP/30U506dUo///yzGjduLEkaMGCA0tPT9cknn+jvv//WNddcU/gdAgCglCCnkdMKm9Puuusu3XXXXXbTBg8erMjISE2ePNnWye3ll1+Wn5+f1q5dq5CQEEnSP/7xD9WrV08vvvii5s+f7/B9AwAAQOnF40oBAKXGbbfdJknav3+/JOuKwn/+85+qX7++/Pz8FBISovvvv18HDhywW27MmDFyc3PTzp079eCDD+qaa66xu1rxyJEjeuSRRxQWFiYfHx81btxYH330UZbr+P33321XlAYFBenhhx+2PSJpzJgxeu655yRJtWrVsj0u4cC+fVJammRMnve1TZs2kqSDB/fZTX/ooYdUs2bNTOUz6pebvOxrdn799Vc1bNhQXl5eWrx4sW655RZdc801io2NzffBuF27dungwYO5lvvqq6/k4eFhO3AmSb6+vurfv7/Wrl2rQ4cO5bj83LlzlZiYqPHjx8vd3V3JyclKT0/PtvxPP/2kr776SlOnTs3zvgAA4HDGWNkhn/nB2UpsVruqPnmRkdX27SOrFSarXenMmTO6dOlSlvOSkpIkSWFhYXbTK1euLHd3d3l7e+d5O4DTGSMlJ1tDCfqMB5whOvryXdxQOOQ0cppU8JyWwcPDQxEREXaPlP3f//6nDh062Dq4SVZGa9eunb777judPXs239sBAABA2cWd3AAApUbGwamMgyYbNmzQmjVr1KtXL1WrVk0HDhzQjBkz1L59e+3cuTPT4xfuv/9+1a1bVxMmTJD5/5MJiYmJat26tdzc3DR48GBVqlRJS5YsUf/+/ZWUlKSnn37abh0PPPCAatWqpYkTJ2rz5s368MMPFRoaqkmTJql79+7as2ePPvvsM02ZMkUVK1aU0tNV6ehR6e+/pRYtJA+PPO1rxkG8oCDH3ZEiv/t6pQsXLmj37t3q3bu3pk+frieffFK33XabvvrqKwUGBua7Lg0bNlS7du20atWqHMtt2bJF9erVy7SNG2+8UZIUFxeniIiIbJdfvny5AgMDdeTIEXXr1k179uxRQECA+vbtqylTptg9tiItLU1DhgzRo48+qiZNmuR7nwAAcJj0dGnLFms8H/nB2ZyR1bp0edpuHfnOapIqVaqU733NyGqOvHtYWcxqGR5++GGdPXtWHh4eatOmjd544w3bHVkkqX379po0aZL69++vsWPHKiQkRGvWrNGMGTP05JNPutTdZIBcnTsnlStnjZ89K/H+BVAMSuQxNZHTslLcOS05OVnnz5/X6dOn9c0332jJkiXq2bOnbX5qaqr8/PwyLefv768LFy5o+/btat26dR72DAAAAKCTGwCUTcnJ2c/z8JCu6NiTY1l3d+nKgxT5KesAp0+f1vHjx5WSkqJffvlF48aNk5+fn+6++25JUpcuXTI91ig6OlpRUVGaP3+++vbtazevWbNmmjt3rt20l156SWlpadq2bZvtQN/AgQPVu3dvjRkzRo8//rjdgZoWLVpo5syZttcnTpzQzJkzNWnSJDVt2lTXX3+9PvvsM3Xr1s26OjQt7fJJ6jzu67p16zR27Fh5e/vo1lvvzleb5SS/+3qlnTt36uLFi1q5cqU++eQTPfroo5oxY4Y8PYs2asTHx6ty5cqZpmdMO3r0aI7L7927V5cuXVLXrl3Vv39/TZw4UatWrdI777yjU6dO6bPPPrOVfe+99/Tnn39q+fLljt0JAACulJ+cdv68VT6rTm6FyWnnzklXnbgsiKLOanv3Si++mHN+uf32x+Xrmzmr7d0rdeiQh6xWgH3NyGo+Pj62fXWEspjVvL291aNHD911112qWLGidu7cqX/9619q06aN1qxZoxYtWkiS7rzzTr3yyiuaMGGCvvnmG9vyL730kl599VUH7hEAoMzjmJrrHFMrwL6S0y4rbE7L8Mwzz+j999+XJLm7u6t79+569913bfPr16+v2NhYpaWlyeP/f7dcuHBB69atk2TdAQ8AAADIKx5XCgBlUbly2Q89etiXDQ3NvmznzvZla9bMvmzbtg7fjQ4dOqhSpUqKiIhQr169VK5cOS1cuFBVq1aVJLuDRxcvXtSJEydUp04dBQcHa/PmzZnWN3DgQLvXxhjNnz9f0dHRMsbo+PHjtqFTp046ffp0pvVcvY42bdroxIkTtkcoOWJf77vvPgUEBOi9975ReHi1Qq03Q0H29Upbt26VJJ06dUp+fn56+eWXC3UwzhiT6xWnknT+/Hn5+Phkmp5xB7bz58/nuPzZs2d17tw59evXT2+//ba6d++ut99+W48//rjmzZunvXv3SrIOrI4aNUovv/xyga4SBgAgz/KT0zp2lIKCHJ/TGjVyyK4UR1b78cec88uOHc7Lat98842qVSOrFSar3XTTTfrqq6/0yCOP6J577tELL7yg2NhYubm5acSIEXZla9asqbZt2+qDDz7Q/Pnz9cgjj2jChAl2J1kBACg0jqmVimNq5LTC57QMTz/9tJYtW6aPP/5YnTt3Vlpami5cuGCb/89//lN79uxR//79tXPnTm3fvl39+vVTfHx8vrYDAAAASNzJDQBQgk2bNk316tWTp6enwsLCVL9+fbm7X+6/ff78eU2cOFGzZs3SkSNHbI9LkKyrOK9Wq1Ytu9d//fWXTp06pQ8++EAffPBBlnU4duyY3evq1avbvc549MHff/9doEcMZMjY19OnT+ujjz7STz/9JG/vzAeiCqog+3qlX3/9VZK0aNEi3X333brvvvv0888/y9vb22F1zIqfn59SU1MzTU9JSbHNz215Serdu7fd9AcffFDvv/++1q5dq7p162rkyJGqUKGChgwZ4qCaAwBQ+hV1Vjt58i8lJeWcX06ccF5Wy+qkYUGV1ayWlTp16qhr165asGCB7Y4g8+bN04ABA7Rnzx7bCevu3bsrPT1dw4cPV+/evW13VQEAABxTI6c5Lqc1aNBADRo0kCT169dPHTt2VHR0tNatWyc3NzcNHDhQhw4d0htvvKGPP/5YktSyZUs9//zzGj9+vMplPKIbAAAAyAM6uQFAWXT2bPbzrn7cVQ4HYeR+1Q1BDxzIe1kHuPHGG9WyZcts5w8ZMkSzZs3S008/raioKAUFBcnNzU29evVSenp6pvJXH7zJKPOPf/xDMTExWW6jadOmdq89snpcmGR3MLAgrtzXbt266ZZbbtGwYQ/qhx92KyDg8sEgNze3LJdPS0vLcf0F2dcrbd26VeHh4br11ls1Y8YMxcTE6KmnntKMGTNy3G5hVa5cOcvHGmRcDVqlSpUcl69SpYp27NihsLAwu+mhoaGSrAOpe/fu1QcffKCpU6faPaohJSVFFy9e1IEDBxQYGKgKFSoUdncAAMhfTvvxR6lZs+wfV3ql/OS0nTtzrGJeuUJWK1fOeVntwQcf1O7du+1O3JHVLHnNatmJiIjQhQsXlJycrMDAQE2fPl0tWrTIdEeWe+65R7Nnz9aWLVvUoUOHAm0LAAA7HFMrFcfUyGlFl9Puu+8+Pf7449qzZ4/q168vSRo/fryeffZZ7dixQ0FBQWrSpIlefPFFSVK9evUKuAcAAAAoi+jkBgBlUUCA88sWg6+++koxMTF68803bdNSUlJ06tSpPC1fqVIllS9fXmlpaQ47KZbdAbP88PDw0MSJE3XrrbfqP/95V48//oJt3jXXXJPl/v355585rrOw+7p161Y1b95cknXV5s8//6z33ntPN910k/r27WtXNj09XVOnTtV7772n48ePq2vXrvrggw/k5eWV7+02b95cK1euVFJSkt1VvevWrbPNz0lkZKSWLVumI0eO2A68SbJ1ZqtUqZKOHDmi9PR0Pfnkk3ryySczraNWrVp66qmnNHXq1HzXHwCATPKTp/z8rPLZnBAs8Hr9/fNethAKm9UqVKikgICc88v/P3k8zxyd1d5991298AJZraBZLTt//PGHfH19bSemExMTbXd7udLFixclSZcuXSrQdgAAyIRjanlaviQcUyOnFU1Oy3j86NV3/Lvmmmt0yy232F4vX75c1apVs90FDgAAAMgLx18CBACAi/Dw8Mh0tec777yT6xWYVy7fo0cPzZ8/X9u3b880/6+//sp3nQL+/6BlXg8KZqd9+/Zq2vRGffzxVKWmptim165dW6dPn9bWrVtt0+Lj47Vw4cIc11eYfU1ISNCxY8fsrkp9++231aJFCw0cOFDbtm2zKz9q1Ch99913WrVqlf7880/t379fH330kV2ZXbt26eDBgznWWbKuDk1LS7N7HERqaqpmzZqlVq1aKSIiQpJ07tw57dq1S8ePH7db/oEHHpAkzZw50276hx9+KE9PT7Vv317XXXedFi5cmGlo3LixqlevroULF6p///651hUAANhzRFbr1Ml1s9qNN96oqVOn2h75JJHVpPxltaz269dff9U333yjjh072h6rVq9ePW3ZskV79uyxK/vZZ5/J3d09x7unAACAzEr7MTVyWuFzWlaPYL148aI++eQT+fn5qVGjRtlu+/PPP9eGDRv09NNP2z0mFwAAAMgNd3IDAJRad999tz799FMFBQWpUaNGWrt2rZYvX66QkJA8r+O1117TypUr1apVKz322GNq1KiRTp48qc2bN2v58uU6efJkvuoUGRkpSXrppZfUq1cveXl4KLpJEwX4+0v5vCL10Uef05NP3q8FC2bruusGSpJ69eql4cOH695779WTTz6pc+fOacaMGapXr542b95cJPv666+/SrJ/9IKvr6+++uorRUZGqkePHtq4caMCAwMVHx+vt956S3v37lV4eLitzps2bbJbZ8OGDdWuXTutWrUqxzq3atVK999/v0aMGKFjx46pTp06+vjjj3XgwAG7jmvr16/XrbfeqtGjR2vMmDG26S1atNAjjzyijz76SJcuXbJt88svv9SIESNsj2bo1q1bpm1n3Lktq3kAABQpNzcp465VDrijhbM4Iqs9++xr2rQp+/yybp19ftm3T/r77+zXlymreXkpOjradlI1P5577jndf//9mj17tgYOJKsVJKv17NlTfn5+uummmxQaGqqdO3fqgw8+kL+/v1577TW7tl6yZInatGmjwYMHKyQkRN99952WLFmiRx99tMCP2wKcwsNDuu++y+MA4AQl4pgaOc2pOe3xxx9XUlKS2rZtq6pVqyohIUFz5szRrl279Oabb9ruuPvTTz9p3Lhx6tixo0JCQhQbG6tZs2bpzjvv1FNPPZVjHQEAAICr0ckNAFBqvfXWW/Lw8NCcOXOUkpKim2++WcuXL1enTp3yvI6wsDCtX79e48aN04IFCzR9+nSFhISocePGmjRpUr7rdMMNN+iVV17Re++9p6VLlyo9PV379+9XQM2a+V5Xx47dVb16bc2c+S+99NJj8vDwUEhIiBYuXKhhw4bp+eefV61atTRx4kTt3bs31wNyBd3XjCtcr75DxrXXXqvZs2fr3nvvVUxMjBYuXKjly5crJSXF7lEEaWlptgOKBfHJJ5/o5Zdf1qeffqq///5bTZs21Xfffae2bdvmafn33ntP1atX16xZs7Rw4ULVqFFDU6ZM0dNPP13gOgEAUKTc3aXatZ1di0JzRFarWLGYsloBTp52795dtWvX1r/+9S899hhZrSBZrVu3bpozZ44mT56spKQkVapUSd27d9fo0aNVp04dW7m2bdtqzZo1GjNmjKZPn64TJ06oVq1aGj9+vJ5//vkC1x1wCl9f6csvnV0LAGVciTqmRk7L9/5nKExO69mzp2bOnKkZM2boxIkTKl++vCIjIzVp0iTdc889tnJVq1aVh4eH3njjDZ05c0a1atXSq6++qmHDhsnTk1OUAAAAyB83c/U9p8ugpKQkBQUF6fTp0woMDHR2dQCg0FJSUrR//37VqlVLvr6+zq4OisjevZfH69Z1Xj3y46233tK2bdv04YcfOrsqxSq3v0mySPZoGwClEVnNMTKyUE456OoyV+an3JYti8hqZLX8om0AOFN0tP3rb7/NPO/KaXlBToOrIqeR0/KLtgEAAM5WFHmEh90jX9zc3PT11187uxoAgGKwd+/lwVGaN2+upUuXateuXZKkEydO6IcffnDcBoAyjJwGACgsshpQdMhqAIDCIKcBAAAAdHIrsdzc3HIcxowZk+2yBw4ckJubm+Li4oqkbgkJCRoyZIiuvfZa+fj4KCIiQtHR0VqxYkWRbC8nBT2AGB8frwcffFD16tWTu7t7to+s+/LLL9WgQQP5+vqqSZMmWrx4sd18Y4xGjRqlypUry8/PTx06dNDeq3qLnDx5Un369FFgYKCCg4PVv39/nT171q7M1q1b1aZNG/n6+ioiIkKvv/56vvcJgItKS5M2brSGtDRn16bItWvXTkOGDNEdd9yhcuXK6cYbb9T27dudXS3AochpeUNOAwqhjOUHFB+yGsoCl89qAwfqWjc3+bi5KaJaNbIaWQ0AJJHTAAAAAIlObiVWfHy8bZg6daoCAwPtpj377LNOqdeBAwcUGRmp//73v3rjjTe0bds2LV26VLfeeqsGDRrklDoVRGpqqipVqqSRI0eqWbNmWZZZs2aNevfurf79+2vLli3q1q2bunXrZvfD8vXXX9fbb7+t9957T+vWrVNAQIA6deqklJQUW5k+ffpox44dWrZsmb777jv99NNPGjBggG1+UlKSOnbsqBo1amjTpk164403NGbMGH3wwQdF1wAAUISGDx+uQ4cO6ezZs9q3b5+eeeYZZ1cJWZgxY4aaNm2qwMBABQYGKioqSkuWLLHNT0lJ0aBBgxQSEqJy5cqpR48eSkxMtFvHwYMH1aVLF/n7+ys0NFTPPfecLl26VNy7UuzIaUWLnAYARYushtLO5bPa6tV6Q9I2SUsXLiSrkdXw/6KjMz+eFChryGkAAAAo8wzM6dOnjSRz+vRpZ1elQGbNmmWCgoJsr9PS0szYsWNN1apVjbe3t2nWrJlZsmSJbb4ku6Fdu3bGGGPWr19vOnToYEJCQkxgYKBp27at2bRpk922JJmFCxdmW5fOnTubqlWrmrNnz2aa9/fff9vG//zzT3PPPfeYgIAAU758eXP//febhIQE2/yYmBjTtWtXu+WfeuopW12NMaZdu3ZmyJAh5rnnnjPXXHONCQsLM6NHj7bNr1Gjht1+1qhRI9t656Rdu3bmqaeeyjT9gQceMF26dLGb1qpVK/P4448bY4xJT0834eHh5o033rDNP3XqlPHx8TGfffaZMcaYnTt3Gklmw4YNtjJLliwxbm5u5siRI8YYY6ZPn26uueYak5qaaiszfPhwU79+/QLtD8qG8+fPm507d5rz5887uyrIzaVLxmzYYA2XLuVr0T17Lg9FoajXX5bk9jfpilnkm2++Md9//73Zs2eP2b17t3nxxReNl5eX2b59uzHGmIEDB5qIiAizYsUKs3HjRtO6dWtz00032Za/dOmSue6660yHDh3Mli1bzOLFi03FihXNiBEj8lUPV2yb/CCnkdOArBQ6qxUiP5QmeckpV5e5Mt+QcZChJGY1V1HS28Yls1piojGSNfx/biOrkdVgzN13W0NW03Kal18cUwNcCzmt4GgbAADgbEWRR7iTWyn01ltv6c0339S//vUvbd26VZ06ddI999xju6X/+vXrJUnLly9XfHy8FixYIEk6c+aMYmJi9PPPPys2NlZ169bVXXfdpTNnzuRpuydPntTSpUs1aNAgBQQEZJofHBwsSUpPT1fXrl118uRJrV69WsuWLdMff/yhnj175ntfP/74YwUEBGjdunV6/fXXNW7cOC1btkyStGHDBknSrFmzFB8fb3ud8WiJVatW5Xt7V1q7dq06dOhgN61Tp05au3atJGn//v1KSEiwKxMUFKRWrVrZyqxdu1bBwcFq2bKlrUyHDh3k7u6udevW2cq0bdtW3t7edtvZvXu3/v7770LtAwAA2YmOjtZdd92lunXrql69eho/frzKlSun2NhYnT59WjNnztTkyZN12223KTIyUrNmzdKaNWsUGxsrSfrxxx+1c+dO/ec//1Hz5s3VuXNnvfLKK5o2bZouXLjg5L1zHnIaOQ1A0dm79/IAAAVBViOroXTgjm8AAAAAUDp5OrsCcLx//etfGj58uHr16iVJmjRpklauXKmpU6dq2rRpqlSpkiQpJCRE4eHhtuVuu+02u/V88MEHCg4O1urVq3X33Xfnut3ff/9dxhg1aNAgx3IrVqzQtm3btH//fkVEREiSPvnkEzVu3FgbNmzQDTfckOd9bdq0qUaPHi1Jqlu3rt59912tWLFCd9xxh20/g4OD7fbTy8tL9evXl7+/f563k5WEhASFhYXZTQsLC1NCQoJtfsa0nMqEhobazff09FSFChXsytSqVSvTOjLmXXPNNYXaDwBl15UngOvWdV494PrS0tL05ZdfKjk5WVFRUdq0aZMuXrxod9KpQYMGql69utauXavWrVtr7dq1atKkid33YKdOnfTEE09ox44datGiRZbbSk1NVWpqqu11UlJS0e2YE5DTyGkAAMB1kdXIagAAAAAAwHVxJ7dSJikpSUePHtXNN99sN/3mm2/Wb7/9luOyiYmJeuyxx1S3bl0FBQUpMDBQZ8+e1cGDB/O0bWNMnsr99ttvioiIsB2Mk6RGjRopODg41zperWnTpnavK1eurGPHjuW4TNWqVbVr1y7deOON+doWAABlzbZt21SuXDn5+Pho4MCBWrhwoRo1aqSEhAR5e3vb7iiR4eqTTlmdlMqYl52JEycqKCjINlyZF0o6cho5DQAAuC6yGlkNAAAAAAC4Njq5wSYmJkZxcXF66623tGbNGsXFxSkkJCTPjxSrW7eu3NzctGvXrkLXxd3dPdMBvosXL2Yq5+XlZffazc1N6enphd5+XoSHhysxMdFuWmJiou0K14x/cytz9QHES5cu6eTJk3ZlslrHldsAAKAo1K9fX3FxcVq3bp2eeOIJxcTEaOfOnUW6zREjRuj06dO24dChQ0W6vZKCnJY/5DQAAFCcyGr5Q1YDAAAAAAAFQSe3UiYwMFBVqlTRL7/8Yjf9l19+UaNGjSRJ3t7ekqxHj11d5sknn9Rdd92lxo0by8fHR8ePH8/ztitUqKBOnTpp2rRpSk5OzjT/1KlTkqSGDRvq0KFDdietd+7cqVOnTtnqWKlSJcXHx9stHxcXl+e6ZPDy8sq0n44SFRWlFStW2E1btmyZoqKiJEm1atVSeHi4XZmkpCStW7fOViYqKkqnTp3Spk2bbGX++9//Kj09Xa1atbKV+emnn+wOSC5btkz169fnsQrIVV6vBocTublJQUHW4ObmtGrs3Xt5gOOV1L9Fb29v1alTR5GRkZo4caKaNWumt956S+Hh4bpw4YLtuz3D1SedCnJCycfHR4GBgXZDaUFOs0dOAwrx/eAi+QEoLUpqVoNjuUxWS0mR7rrLGjw8JJHVJLJaWRQdbQ3OwncD4Br4WwQAAMCV6ORWCj333HOaNGmSPv/8c+3evVsvvPCC4uLi9NRTT0mSQkND5efnp6VLlyoxMVGnT5+WZF01+umnn+q3337TunXr1KdPH/n5+eVr29OmTVNaWppuvPFGzZ8/X3v37tVvv/2mt99+23YQqkOHDmrSpIn69OmjzZs3a/369erXr5/atWunli1bSpJuu+02bdy4UZ988on27t2r0aNHa/v27flui5o1a2rFihVKSEjQ33//LUk6cuSIGjRooPXr1+e4bFxcnOLi4nT27Fn99ddfiouLs7t7zVNPPaWlS5fqzTff1K5duzRmzBht3LhRgwcPlmRdAfv000/r1Vdf1TfffKNt27apX79+qlKlirp16ybJOjh555136rHHHtP69ev1yy+/aPDgwerVq5eqVKkiSXrwwQfl7e2t/v37a8eOHfr888/11ltvadiwYfluD5QdGVdknzt3zsk1Qa7c3aW6da3B3fW/lukMVzAZf4tX3y2hpElPT1dqaqoiIyPl5eVld9Jp9+7dOnjwoN1Jp23bttndXWHZsmUKDAy0nYAri8hpl5HTUJYVOquVsPwAuLrk5GS5ubmV+KyGwnOJrNa2reY/8oj2Tp2q3/bvJ6uR1VDMOKYGuJbSckwNAAAAjuHp7ArA8Z588kmdPn1azzzzjI4dO6ZGjRrpm2++Ud26dSVJnp6eevvttzVu3DiNGjVKbdq00apVqzRz5kwNGDBA119/vSIiIjRhwgQ9++yz+dr2tddeq82bN2v8+PF65plnFB8fr0qVKikyMlIzZsyQZB2oWrRokYYMGaK2bdvK3d1dd955p9555x3bejp16qSXX35Zzz//vFJSUvTII4+oX79+2rZtW77q8+abb2rYsGH697//rapVq+rAgQO6ePGidu/eneuBihYtWtjGN23apLlz56pGjRo6cOCAJOmmm27S3LlzNXLkSL344ouqW7euvv76a1133XW25Z5//nklJydrwIABOnXqlG655RYtXbpUvr6+tjJz5szR4MGDdfvtt8vd3V09evTQ22+/bZsfFBSkH3/8UYMGDVJkZKQqVqyoUaNGacCAAflqC5QtHh4eCg4OtnUu8ff3lxt3+Sh1rryoPiWlcMtfKWNdWa2/sNssa4wxOnfunI4dO6bg4GB5/P+dGEqCESNGqHPnzqpevbrOnDmjuXPnatWqVfrhhx8UFBSk/v37a9iwYapQoYICAwM1ZMgQRUVFqXXr1pKkjh07qlGjRurbt69ef/11JSQkaOTIkRo0aJB8fHycvHfOQ067jJyGsoys5hgZuSQv2SWrMldOR9ljjNGlS5eUlJSkpKSkEpfVUDTIapeR1VBWkdMA11CSj6kBAACg6LgZ7vWrpKQkBQUF6fTp06XqkVgAyjZjjBISEjI9ThClxxU3yFJoaMGWy0rGurJaf0G3WdYFBwcrPDw82wPjrphF+vfvrxUrVig+Pl5BQUFq2rSphg8frjvuuEOSlJKSomeeeUafffaZUlNT1alTJ02fPt3uUaR//vmnnnjiCa1atUoBAQGKiYnRa6+9Jk/PvF9n4YptAwCOQFYrvIxcklVOuVp2Zcgz8PDwUGhoqIKCgkpUVnMVtA2AopLxqNJvv838OrvHmF5d9spp+UFOA1xHSTym5ipoGwAA4GxFkUe4kxsAlFJubm6qXLmyQkNDdfHiRWdXB9k5d066+WZr/JdfJH//PC/6+uuXx///wv58L5eVjHVltf6CbrMs8/LyKpFXm86cOTPH+b6+vpo2bZqmTZuWbZkaNWpo8eLFjq4aAJQKhcpqhcgPpUlGLskqp1wtuzLkmbLN09NTHh4e3KEHriU52b5nbkCAc+sDlEEcUwNcQ0k9pgYAAICiQyc3ACjlPDw8OBjgytLSpF27rHEfH+mKR6/k5vjxy+O5LZbdVc5ZyVhXVuvPzzYBAEDuCpTVCpEfSpOMXJJVTrladmXKaNMBcHW5PA4UQPHgmBoAAAAAuBY6uQEAADv56RAHAAAAAAAAAAAAAEBRo5MbAAAAAAAo1ejEDwAAAAAAAAAlG53cAAAoZTJO4n77rXPrAQAAUBTosAYAAAAAAAAAZQ+d3AAAQK44mQwAAAAAAAAAAAAAcBZ3Z1cAAAAAAAAAAAAAAAAAAIDs0MkNAABncneX2rWzBne+lgEAQB6QH4Ayb8aMGWratKkCAwMVGBioqKgoLVmyxDY/JSVFgwYNUkhIiMqVK6cePXooMTHRbh0HDx5Uly5d5O/vr9DQUD333HO6dOlSce8KrsZnPAAAAAAAQJZ4XCkAAM7k5yetWuXsWgAAgJKE/ACUedWqVdNrr72munXryhijjz/+WF27dtWWLVvUuHFjDR06VN9//72+/PJLBQUFafDgwerevbt++eUXSVJaWpq6dOmi8PBwrVmzRvHx8erXr5+8vLw0YcIEJ+9dGcdnPAAAAAAAQJacejkgV50CAAAAAAAA+RMdHa277rpLdevWVb169TR+/HiVK1dOsbGxOn36tGbOnKnJkyfrtttuU2RkpGbNmqU1a9YoNjZWkvTjjz9q586d+s9//qPmzZurc+fOeuWVVzRt2jRduHDByXsHAI4THW0NAAAAAICSz6md3DKuOt20aZM2btyo2267TV27dtWOHTskSUOHDtW3336rL7/8UqtXr9bRo0fVvXt32/IZV51euHBBa9as0ccff6zZs2dr1KhRztolAAAAAAAAoNikpaVp3rx5Sk5OVlRUlDZt2qSLFy+qQ4cOtjINGjRQ9erVtXbtWknS2rVr1aRJE4WFhdnKdOrUSUlJSbbjcgAAAAAAAIArcerjSqOvuoRq/PjxmjFjhmJjY1WtWjXNnDlTc+fO1W233SZJmjVrlho2bKjY2Fi1bt3adtXp8uXLFRYWpubNm+uVV17R8OHDNWbMGHl7eztjtwAAyLvkZKlmTWv8wAEpIMCZtQEAACUB+QGApG3btikqKkopKSkqV66cFi5cqEaNGikuLk7e3t4KDg62Kx8WFqaEhARJUkJCgl0Ht4z5GfOyk5qaqtTUVNvrpKQkB+0NbPiMBwAAAAAAyJJT7+R2Ja46BQCUWcePW0MJk/HIDx77AQCAE5TQ/OBqyDMoyerXr6+4uDitW7dOTzzxhGJiYrRz584i3ebEiRMVFBRkGyIiIop0e2UWn/EAAAAAAACZOL2T27Zt21SuXDn5+Pho4MCBtqtOExISivSq06SkJLsBAAAAAAAAKCm8vb1Vp04dRUZGauLEiWrWrJneeusthYeH68KFCzp16pRd+cTERIWHh0uSwsPDlZiYmGl+xrzsjBgxQqdPn7YNhw4dcuxOAQAAAAAAANlweic3rjoFAAAAAACugju7oaRKT09XamqqIiMj5eXlpRUrVtjm7d69WwcPHlRUVJQkKSoqStu2bdOxY8dsZZYtW6bAwEA1atQo2234+PgoMDDQbgAAAAAAAACKg6ezK5Bx1akkRUZGasOGDXrrrbfUs2dP21WnV97N7eqrTtevX2+3vrxedTps2DDb66SkJDq6AQAAAAAAoEQYMWKEOnfurOrVq+vMmTOaO3euVq1apR9++EFBQUHq37+/hg0bpgoVKigwMFBDhgxRVFSUWrduLUnq2LGjGjVqpL59++r1119XQkKCRo4cqUGDBsnHx8fJewcAAAAAAABk5vQ7uV2Nq04BAAAAAACA7B07dkz9+vVT/fr1dfvtt2vDhg364YcfdMcdd0iSpkyZorvvvls9evRQ27ZtFR4ergULFtiW9/Dw0HfffScPDw9FRUXpH//4h/r166dx48Y5a5cAAAAAAACAHDn1Tm5cdQoAAAAAAADkz8yZM3Oc7+vrq2nTpmnatGnZlqlRo4YWL17s6KoBAAAAAAAARcKpndwyrjqNj49XUFCQmjZtmumqU3d3d/Xo0UOpqanq1KmTpk+fbls+46rTJ554QlFRUQoICFBMTAxXnQIASg53d6lly8vjAAAAuSE/AEDpxWc8UGDR0c6uAQAAAACgKDm1kxtXnQIAyjw/P2nDhiJZNQd3AQAopYowPwAAnIzPeAAAAAAAgCxxOSAAAAAAAAAAAAAAAAAAwGXRyQ0AAAAAAAAAAAAAAAAA4LLo5AYAgDOdOyfVrGkN5845uzYAAKAkID8AQOnFZzwAAAAAAECWPJ1dAQAAyjRjpD//vDxeQNHRDqoPAABwfQ7KDwAAF8RnPAAAAAAAQJa4kxsAAAAAAAAAAAAAAAAAwGVxJzcAAAAAAODyuHMtAAAAAAAAAJRddHIDAAAAAABlHp3oAAAAAAAAAMB18bhSAAAAAAAAAAAAAAAAAIDLopMbAAAAAAAAAAAAABSRadOmqWbNmvL19VWrVq20fv36HMtPnTpV9evXl5+fnyIiIjR06FClpKQUU20BAABcE48rBQDAmdzcpEaNLo8DAADkhvwAAKUXn/EAAJQ6n3/+uYYNG6b33ntPrVq10tSpU9WpUyft3r1boaGhmcrPnTtXL7zwgj766CPddNNN2rNnjx566CG5ublp8uTJTtgDAAAA10AnNwAAnMnfX9qxw9m1AAAAJUkZyA/R0da/337r3HoAQLErA5/xAACUNZMnT9Zjjz2mhx9+WJL03nvv6fvvv9dHH32kF154IVP5NWvW6Oabb9aDDz4oSapZs6Z69+6tdevWFWu9AQAAXA2PKwUAAAAAACVWdPTlTnEAAAAA4EouXLigTZs2qUOHDrZp7u7u6tChg9auXZvlMjfddJM2bdpke6TpH3/8ocWLF+uuu+4qljoDAAC4Ku7kBgAAAAAAAAAAAAAOdvz4caWlpSksLMxuelhYmHbt2pXlMg8++KCOHz+uW265RcYYXbp0SQMHDtSLL76Y7XZSU1OVmppqe52UlOSYHQAAAHAh3MkNAABnOndOatzYGs6dy9Mi3K0EAIAyrgD5AQBQQvAZD9jhGAiAsmjVqlWaMGGCpk+frs2bN2vBggX6/vvv9corr2S7zMSJExUUFGQbIiIiirHGAAAAxYM7uQEA4EzGSDt3Xh7PBgd0AQCATR7zAwCgBOIzHgCAUqVixYry8PBQYmKi3fTExESFh4dnuczLL7+svn376tFHH5UkNWnSRMnJyRowYIBeeuklubtnvofJiBEjNGzYMNvrpKQkOroBAIBShzu5AQCAQuPKagAAAAAAAACw5+3trcjISK1YscI2LT09XStWrFBUVFSWy5w7dy5TRzYPDw9JksmmE7yPj48CAwPtBgAAgNKGO7kBAAAAAAAAAACn4wI6AKXRsGHDFBMTo5YtW+rGG2/U1KlTlZycrIcffliS1K9fP1WtWlUTJ06UJEVHR2vy5Mlq0aKFWrVqpd9//10vv/yyoqOjbZ3dAAAAyiI6uQEAAAAAAAAAAABAEejZs6f++usvjRo1SgkJCWrevLmWLl2qsLAwSdLBgwft7tw2cuRIubm5aeTIkTpy5IgqVaqk6OhojR8/3lm7AAAA4BLo5AYAAAAAAAAAAAAARWTw4MEaPHhwlvNWrVpl99rT01OjR4/W6NGji6FmAAAAJYd77kUAAAAAAAAAAAAAAAAAAHAO7uQGAIAzublJNWpcHgcAAMgN+QEASi8+4wEAAAAAALJEJzcAAJzJ3186cMDZtQAAACUJ+QEASi8+44EcRUc7uwYAAAAAAGfhcaUAAAAAAAAAAAAAAAAAAJdFJzcAAAAAAICrREdztxgAAEobvt8BAAAAoOSikxsAAM50/rx0ww3WcP68s2sDAABKAvIDAJRefMYDAAAAAABkydPZFQAAoExLT5c2brw8DgAAkBvyAwCUXnzGAwAAAAAAZIk7uQEAAAAAAAAAAAAAAAAAXBad3AAAgMNER18eULJNnDhRN9xwg8qXL6/Q0FB169ZNu3fvtivTvn17ubm52Q0DBw60K3Pw4EF16dJF/v7+Cg0N1XPPPadLly4V564AAAAAAAAAAAAAKOF4XCkAAAAyWb16tQYNGqQbbrhBly5d0osvvqiOHTtq586dCggIsJV77LHHNG7cONtrf39/23haWpq6dOmi8PBwrVmzRvHx8erXr5+8vLw0YcKEYt0fAAAAAAAAAAAAACUXndwAAACQydKlS+1ez549W6Ghodq0aZPatm1rm+7v76/w8PAs1/Hjjz9q586dWr58ucLCwtS8eXO98sorGj58uMaMGSNvb+8i3QcAAAAAAAAAAAAApQOPKwUAAECuTp8+LUmqUKGC3fQ5c+aoYsWKuu666zRixAidO3fONm/t2rVq0qSJwsLCbNM6deqkpKQk7dixI8vtpKamKikpyW4AAAAAAAAAAAAAULZxJzcAAJytYkVn1wDIUXp6up5++mndfPPNuu6662zTH3zwQdWoUUNVqlTR1q1bNXz4cO3evVsLFiyQJCUkJNh1cJNke52QkJDltiZOnKixY8cW0Z4AQClCfgCA0ovPeAAAAAAAgEzo5AYAgDMFBEh//eXsWgA5GjRokLZv366ff/7ZbvqAAQNs402aNFHlypV1++23a9++fapdu3aBtjVixAgNGzbM9jopKUkREREFqzgAlFbkBwAovfiMBwAAAAAAyBKPKwUAAEC2Bg8erO+++04rV65UtWrVcizbqlUrSdLvv/8uSQoPD1diYqJdmYzX4eHhWa7Dx8dHgYGBdgMAAAAAAAAAAACAso1ObgAAAMjEGKPBgwdr4cKF+u9//6tatWrlukxcXJyk/2vv3uO8quv8gb9mBhguCojKDBiJWt5vpUZkmheWiy7paqVmiq6rvzVoKzZrKfPaRtuaWUa5XYR2kzR3zRVzMUXRTfFGYd6yRAxLB28rCOpwmfP74xujI4PcZub7nZnn8/E4D873nPM93/c53+985sVnPt9zkiFDhiRJRo4cmYceeijPPfdc8za33HJL+vfvnz333LNd6gYAAIC3Gj++NAEAANB5GeQGAOX02mvJYYeVptdeK3c10GzixIn5yU9+kpkzZ2brrbdOQ0NDGhoa8tpfPqcLFy7MxRdfnPnz5+epp57KDTfckFNPPTWHHnpo9t133yTJ6NGjs+eee+aUU07Jgw8+mJtvvjnnnntuJk6cmNra2nIeHkDnJj90KH8UBzqUNh4AAACgVT3KXQAAdGtNTckdd7wxDxXie9/7XpLksMMOa7F8+vTpOe2009KrV6/ceuutueyyy7JixYoMGzYsxx9/fM4999zmbWtqanLjjTfm7LPPzsiRI9OvX79MmDAhF110UUceCkDXIz8AdF3aeLoxg8oBAAB4Owa5AQCwjqIo3nb9sGHDcsfaP769jR133DE33XRTW5UFAAAAAAAAdEMGuQEAAAAVyRVdAAAAAABIkupyFwAAAAAAAAAAAADrY5AbAAAAAAAAAAAAFcvtSgEAAICK4PakAAAAAAC0xpXcAKDc+vYtTQAAG0t+gG5t6tSpOeigg7L11ltn8ODBOfbYY/P444+32Oawww5LVVVVi+nv//7vW2yzePHiHH300enbt28GDx6cc845J6tXr+7IQ6E12ngAAACAdZR1kJsOOQC6vX79khUrSlO/fuWuBgDoDOQH6PbuuOOOTJw4Mffcc09uueWWrFq1KqNHj86KFStabHfmmWfm2WefbZ6+/vWvN69bs2ZNjj766KxcuTJ33313fvzjH2fGjBk577zzOvpweDNtPAAAAECrynq70rUdcgcddFBWr16dL37xixk9enQeffTR9HtTJ86ZZ56Ziy66qPlx3zd9k3Fth1x9fX3uvvvuPPvsszn11FPTs2fPfPWrX+3Q4wEAAACA9jZ79uwWj2fMmJHBgwdn/vz5OfTQQ5uX9+3bN/X19a3u45e//GUeffTR3Hrrramrq8v++++fiy++OF/4whdywQUXpFevXu16DAAAAACwKcp6JbfZs2fntNNOy1577ZX99tsvM2bMyOLFizN//vwW263tkFs79e/fv3nd2g65n/zkJ9l///0zbty4XHzxxZk2bVpWrlzZ0YcEAAAAAB1q6dKlSZJBgwa1WH7VVVdlu+22y957750pU6bk1VdfbV43b9687LPPPqmrq2teNmbMmCxbtiyPPPJIq6/T2NiYZcuWtZgAAAAAoCOUdZDbW3VUhxwAVIzXX0+OPro0vf56uasBADqDLpAfxo8vTcCWa2pqymc+85kcfPDB2XvvvZuXf/zjH89PfvKT3H777ZkyZUr+4z/+I5/4xCea1zc0NLToT0vS/LihoaHV15o6dWoGDBjQPA0bNqwdjqib6wJtPAAAAEB7KOvtSt/s7TrkdtxxxwwdOjS//e1v84UvfCGPP/54rrvuuiSb1yHX2NiYxsbG5se+dQpA2axZk9x00xvzAAAbIj8AbzJx4sQ8/PDD+dWvftVi+VlnndU8v88++2TIkCE58sgjs3Dhwuyyyy6b9VpTpkzJ5MmTmx8vW7bMQLe2po0HAAAAaFXFDHLryA65qVOn5sILL9yiegEAAACgnCZNmpQbb7wxd955Z97xjne87bYjRoxIkjzxxBPZZZddUl9fn/vuu6/FNkuWLEmS1NfXt7qP2tra1NbWtkHlAAAAALBpKuJ2pWs75G6//fZN6pBLSp1uazvg1tpQh9yUKVOydOnS5unpp5/e0kMAAAAAgA5RFEUmTZqUn//857ntttuy0047bfA5CxYsSJIMGTIkSTJy5Mg89NBDee6555q3ueWWW9K/f//sueee7VI3AAAAAGyusg5yK1eHXG1tbfr3799iAgAAAIDOYOLEifnJT36SmTNnZuutt05DQ0MaGhry2muvJUkWLlyYiy++OPPnz89TTz2VG264IaeeemoOPfTQ7LvvvkmS0aNHZ88998wpp5ySBx98MDfffHPOPffcTJw40dXaAAAAAKg4Zb1d6cSJEzNz5sz893//d3OHXJIMGDAgffr0ycKFCzNz5swcddRR2XbbbfPb3/42n/3sZ9fbIff1r389DQ0NOuQAoAKMH//G/KxZ5asDAAC6mu9973tJksMOO6zF8unTp+e0005Lr169cuutt+ayyy7LihUrMmzYsBx//PE599xzm7etqanJjTfemLPPPjsjR45Mv379MmHChFx00UUdeSgAAAAAsFHKOshNhxwAAAAAbJqiKN52/bBhw3LHHXdscD877rhjbrrpprYqCwAAAADaTVkHuemQAwAAAAAAAAAA4O2UdZAbAHR7/fol6xn0/ebbfQIANHub/ABAJ6eNpxvS/wEAAMDGqC53AQAAAAAAAAAAALA+BrkBAAAAAAAAAABQsdyuFADK6fXXk1NOKc3/x38kvXuXtx4AoPJ1wfzgNmUAf9EF23gAAACAtuBKbgBQTmvWJP/5n6VpzZpyVwMAdAbyA0DXpY0HAAAAaJVBbgAAAAAAAAAAAFQstysFgArjdl0AAAAAAAAA8AZXcgMAAAAAAAAAAKBiGeQGAAAAAAAAAABAxTLIDQAAAGAzjB/vVvMAAAAAAB3BIDcAoN35AzAAAAAAAAAAm6tHuQsAgG6tb99k+fI35gEANkR+KIu1A/ZnzSpvHUAXp40HAAAAaJVBbgBQTlVVSb9+5a4CAOhM5AeArksbTxdmwDgAAABbwiA3AAAAAACgQ60d9AYAAAAbo7rcBQBAt9bYmJx2WmlqbCx3NQBAZyA/AHRd2ngAAACAVhnkBgDltHp18uMfl6bVq8tdDQDQGcgPAF2XNh4AAACgVQa5AQAAAAAAAAAAULF6lLsAAAAAoHsaP77cFQAAAAAA0Bm4khsAAAAAAAAAAAAVyyA3AAAAAAAAAAAAKpZBbgAAAAAAQLfhlukAAACdj0FuAAAAAAAAAAAAVKwe5S4AALq1vn2T557LyScny07om1SVuyAAoOL9JT80zwPQdWjjocOtvarbrFnlrQMAAIC3Z5AbAJRTVVWy/fZZVlvuQgCATuMv+aGz8IdjgE3Qydp4AAAAgI7idqUAAAAAAAAAAABULIPcAKCcGhuTiRPz9w9NTI81jeWuBgDoDP6SHzJxYmkegK5DGw8AAADQKoPcAKCcVq9OvvvdHP3H76amWF3uagCAzuAv+SHf/W5pHoCuQxsPAAAA0CqD3AAAAAAAAAAAAKhYBrkBAAAAAAAAAABQsQxyAwAAAAAAAAAAoGIZ5AYAwDqmTp2agw46KFtvvXUGDx6cY489No8//niLbV5//fVMnDgx2267bbbaaqscf/zxWbJkSYttFi9enKOPPjp9+/bN4MGDc84552T16tUdeSgA0KbGj39jAgA2nd+jAAAAbA6D3AAAWMcdd9yRiRMn5p577sktt9ySVatWZfTo0VmxYkXzNp/97Gcza9asXHvttbnjjjvyzDPP5Ljjjmtev2bNmhx99NFZuXJl7r777vz4xz/OjBkzct5555XjkAAAAACgLKZNm5bhw4end+/eGTFiRO6777633f7ll1/OxIkTM2TIkNTW1mbXXXfNTTfd1EHVAgBUph7lLgAAgMoze/bsFo9nzJiRwYMHZ/78+Tn00EOzdOnS/OhHP8rMmTNzxBFHJEmmT5+ePfbYI/fcc0/e//7355e//GUeffTR3Hrrramrq8v++++fiy++OF/4whdywQUXpFevXuU4NAAAAADoMNdcc00mT56cK664IiNGjMhll12WMWPG5PHHH8/gwYPX2X7lypX5q7/6qwwePDj/+Z//mR122CF//OMfM3DgwI4vHgCggriSGwCUU58+yaJFOeOIRVlZ06fc1cB6LV26NEkyaNCgJMn8+fOzatWqjBo1qnmb3XffPe985zszb968JMm8efOyzz77pK6urnmbMWPGZNmyZXnkkUc6sHqALuYv+SGLFpXmAeg6tPEA0OVceumlOfPMM3P66adnzz33zBVXXJG+ffvmyiuvbHX7K6+8Mi+99FKuv/76HHzwwRk+fHg+9KEPZb/99uvgygEAKotBbgBQTtXVyfDhea7v8BRVfi1TmZqamvKZz3wmBx98cPbee+8kSUNDQ3r16rXON0jr6urS0NDQvM2bB7itXb92XWsaGxuzbNmyFhMAb/GX/JDhw0vzAHQd2ngA6FJWrlyZ+fPnt/iiaHV1dUaNGtX8RdG3uuGGGzJy5MhMnDgxdXV12XvvvfPVr341a9asWe/r6FMDALoDPSUAALytiRMn5uGHH87VV1/d7q81derUDBgwoHkaNmxYu78mAAAA3c/48aVpfY8B2sILL7yQNWvWtPpF0PV9CfTJJ5/Mf/7nf2bNmjW56aab8uUvfznf+MY38pWvfGW9r6NPDQDoDgxyA4ByWrkyOeecnP7oOenRtLLc1cA6Jk2alBtvvDG333573vGOdzQvr6+vz8qVK/Pyyy+32H7JkiWpr69v3mbJkiXrrF+7rjVTpkzJ0qVLm6enn366DY8GoIv4S37IOeeU5juJtX849sdjgLfRSdt4AKDtNDU1ZfDgwfn+97+fAw44ICeccEK+9KUv5Yorrljvc/SpAQDdgUFuAFBOq1Yll1yS4568JDVNq8pdDTQriiKTJk3Kz3/+89x2223ZaaedWqw/4IAD0rNnz8yZM6d52eOPP57Fixdn5MiRSZKRI0fmoYceynPPPde8zS233JL+/ftnzz33bPV1a2tr079//xYTAG/xl/yQSy4pzQPQdWjj6aIMcge6q+222y41NTWtfhF0fV8CHTJkSHbdddfU1NQ0L9tjjz3S0NCQlesZBK9PDQDoDgxyAwBgHRMnTsxPfvKTzJw5M1tvvXUaGhrS0NCQ1157LUkyYMCAnHHGGZk8eXJuv/32zJ8/P6effnpGjhyZ97///UmS0aNHZ88998wpp5ySBx98MDfffHPOPffcTJw4MbW1teU8PAAAAABod7169coBBxzQ4ouiTU1NmTNnTvMXRd/q4IMPzhNPPJGmpqbmZb///e8zZMiQ9OrVq91rBgCoVAa5AQCwju9973tZunRpDjvssAwZMqR5uuaaa5q3+eY3v5m//uu/zvHHH59DDz009fX1ue6665rX19TU5MYbb0xNTU1GjhyZT3ziEzn11FNz0UUXleOQAAAAAKDDTZ48OT/4wQ/y4x//OI899ljOPvvsrFixIqeffnqS5NRTT82UKVOatz/77LPz0ksv5dOf/nR+//vf5xe/+EW++tWvZuLEieU6BACAitCj3AUAAFB5iqLY4Da9e/fOtGnTMm3atPVus+OOO+amm25qy9IAAAAAoNM44YQT8vzzz+e8885LQ0ND9t9//8yePTt1dXVJksWLF6e6+o3rkgwbNiw333xzPvvZz2bffffNDjvskE9/+tP5whe+UK5DAACoCAa5AQAAAAAAALSTSZMmZdKkSa2umzt37jrLRo4cmXvuuaedqwIA6FzcrhQAAAAAOpGpU6fmoIMOytZbb53Bgwfn2GOPzeOPP95im9dffz0TJ07Mtttum6222irHH398lixZ0mKbxYsX5+ijj07fvn0zePDgnHPOOVm9enVHHgoAAAAAbJSyDnLTIQcAAAAAm+aOO+7IxIkTc8899+SWW27JqlWrMnr06KxYsaJ5m89+9rOZNWtWrr322txxxx155plnctxxxzWvX7NmTY4++uisXLkyd999d3784x9nxowZOe+888pxSAAAAADwtsp6u9K1HXIHHXRQVq9enS9+8YsZPXp0Hn300fTr1y9JqUPuF7/4Ra699toMGDAgkyZNynHHHZe77roryRsdcvX19bn77rvz7LPP5tRTT03Pnj3z1a9+tZyHBwAb1jwr1WEAAFUGSURBVKdP8vDDmTgxWVnTp9zVAACdwV/yQ/M80O3Mnj27xeMZM2Zk8ODBmT9/fg499NAsXbo0P/rRjzJz5swcccQRSZLp06dnjz32yD333JP3v//9+eUvf5lHH300t956a+rq6rL//vvn4osvzhe+8IVccMEF6dWrVzkODW08AAAAQKvKeiW32bNn57TTTstee+2V/fbbLzNmzMjixYszf/78JGnukLv00ktzxBFH5IADDsj06dNz9913N9+Hfm2H3E9+8pPsv//+GTduXC6++OJMmzYtK1euLOfhAcCGVVcne+2VxVvvlaLKXcQBgI3wl/yQvfYqzQPd3tKlS5MkgwYNSpLMnz8/q1atyqhRo5q32X333fPOd74z8+bNS5LMmzcv++yzT+rq6pq3GTNmTJYtW5ZHHnmkA6unBW08AAAAQKsqqqdEhxwAAAAAbLympqZ85jOfycEHH5y99947SdLQ0JBevXpl4MCBLbatq6tLQ0ND8zZv7k9bu37tutY0NjZm2bJlLSaArmb8+NIEAABAZamYQW465ADollauTC64ICc9fkF6NLkCKQCwEf6SH3LBBaV5oFubOHFiHn744Vx99dXt/lpTp07NgAEDmqdhw4a1+2t2O9p4AAAAgFZVzCA3HXIAdEurViUXXpiP/+HC1DStKnc1AEBn8Jf8kAsvLM0D3dakSZNy44035vbbb8873vGO5uX19fVZuXJlXn755RbbL1myJPX19c3bLFmyZJ31a9e1ZsqUKVm6dGnz9PTTT7fh0ZBEGw8AAACwHhUxyE2HHADd1Uc+Uu4KAACAzqYoikyaNCk///nPc9ttt2WnnXZqsf6AAw5Iz549M2fOnOZljz/+eBYvXpyRI0cmSUaOHJmHHnoozz33XPM2t9xyS/r3758999yz1detra1N//79W0wAAAAA0BHKOshNhxwAdC/jx78xAQAAm2fixIn5yU9+kpkzZ2brrbdOQ0NDGhoa8tprryVJBgwYkDPOOCOTJ0/O7bffnvnz5+f000/PyJEj8/73vz9JMnr06Oy555455ZRT8uCDD+bmm2/Oueeem4kTJ6a2trachwcAAAAA6+hRzhefOHFiZs6cmf/+7/9u7pBLSh1xffr0adEhN2jQoPTv3z+f+tSn1tsh9/Wvfz0NDQ065AAAAADosr73ve8lSQ477LAWy6dPn57TTjstSfLNb34z1dXVOf7449PY2JgxY8bku9/9bvO2NTU1ufHGG3P22Wdn5MiR6devXyZMmJCLLrqoow4DAAAAADZaWQe56ZADAAAAgE1TFMUGt+ndu3emTZuWadOmrXebHXfcMTfddFNblgYAAAAA7aKsg9x0yAEAAAAAAAAAAPB2qstdAAAAAAAAAAAAAKzPZg1y23nnnfPiiy+us/zll1/OzjvvvMVFAUB3saqmdyZ/8L5M/uB9WVXTu9zl0AXIaQDdQO/eyX33labe8gN0JrIaG6SNh4oxfnxpAgAAoDJs1u1Kn3rqqaxZs2ad5Y2Njfnzn/+8xUUBQHfRVFWTPww8qNxl0IXIaQDdQE1NcpD8AJ2RrMYGaeMBAAAAWrVJg9xuuOGG5vmbb745AwYMaH68Zs2azJkzJ8OHD2+z4gAA2DhyGgBA5ZLVAAAAAGDLbNIgt2OPPTZJUlVVlQkTJrRY17NnzwwfPjzf+MY32qw4AOjqejStzPhF30qSzNrp01ld3avMFXWcN9/yY9as8tXRVchpAN3IypXJt0r5IZ/+dNKr++SHSrU218g0rI+sxkbTxgMAAAC0apMGuTU1NSVJdtppp9x///3Zbrvt2qUoAOguappW5W8f+3yS5KYdP9mtBrnRtuQ0gG5k1ark86X8kE9+0gAI6ARkNTaaNh4AAACgVZs0yG2tRYsWtXUdAAC0ATkNAKByyWoAAAAAsHk2a5BbksyZMydz5szJc8891/xt1LWuvPLKLS4MAIDNI6cBAFQuWQ0AAAAANt1mDXK78MILc9FFF+XAAw/MkCFDUlVV1dZ1AQCwGeQ0AIDKJasBAAAAwObZrEFuV1xxRWbMmJFTTjmlresBAGALyGkAAJVLVgMAAACAzVO9OU9auXJlPvCBD7R1LQAAbCE5DQCgcslqAAAAALB5NmuQ29/93d9l5syZbV0LANBNjR9fmthychoAQOWS1QAAAABg82zW7Upff/31fP/738+tt96afffdNz179myx/tJLL22T4gCgq1tV0ztT3n978zxsKTkNoBvo3Tu5/fY35oFOQ1Zjg7TxdBFrv8g2a1Z56wAAAKDr2KxBbr/97W+z//77J0kefvjhFuuqqqq2uCgA6MpaXLGsqiYPb3dYuUqhC5LTALqBmprksMPKXQWwGWQ1NkgbDwAAANCqzRrkdvvabxMCAFBR5DQAgMolqwHdTYsv+gEAAMAW2KxBbgBA26hpWpUxi7+fJLn5nWdlTXXPDTwDAOj2Vq1Kvl/KDznrrKSn/ADQZWjjAQAAAFq1WYPcDj/88Le9hcJtt9222QUBQHfSo2llzn54UpJkzjtOM8iNLSanAXQDK1cmk0r5IaedZgAEdCKyGhukjQcAAABo1WYNctt///1bPF61alUWLFiQhx9+OBMmTGiLugAA2AxyGgBA5ZLVAAAAAGDzbNYgt29+85utLr/ggguyfPnyLSoIAIDNJ6cBQPmNH1/6d9as8tZB5ZHVAAAAAGDzVLflzj7xiU/kyiuvbMtdAgDQBuQ0AIDKJasBAAAAwNvbrCu5rc+8efPSu3fvttwlAHQJa6/mAeUipwEAVC5ZDQAAAADe3mYNcjvuuONaPC6KIs8++2weeOCBfPnLX26TwgAA2HRyGgCVwiB/WJesBgAAAACbZ7MGuQ0YMKDF4+rq6uy222656KKLMnr06DYpDACATSenAQBULlkNAAAAADbPZg1ymz59elvXAQDd0qrq2lx40I3N87Cl5DSAbqC2NrnxxjfmgU5DVmODtPEAAAAArdqsQW5rzZ8/P4899liSZK+99sp73vOeNikKALqLpuoeeaDu6HKXQRckpwF0YT16JEfLD9CZyWqslzYeAAAAoFWbNcjtueeey4knnpi5c+dm4MCBSZKXX345hx9+eK6++upsv/32bVkjAAAbSU4DoNzGjy93BVC5ZDUAAAAA2DzVm/OkT33qU3nllVfyyCOP5KWXXspLL72Uhx9+OMuWLcs//MM/tHWNANBl1TStypFPz8iRT89ITdOqcpdDFyCnAXQDq1YlM2aUplXyA3QmshobpI0HAAAAaNVmXclt9uzZufXWW7PHHns0L9tzzz0zbdq0jB49us2KA4CurkfTynzmwdOTJL8a8tGsqe5Z5oro7OQ0gG5g5crk9FJ+yEc/mvSUH6CzkNXYIG08AAAAQKs260puTU1N6dlKB0vPnj3T1NS0xUUBALB55DQAgMolqwEAAADA5tmsQW5HHHFEPv3pT+eZZ55pXvbnP/85n/3sZ3PkkUe2WXEAAGwaOQ0AoHLJagAAAACweTZrkNt3vvOdLFu2LMOHD88uu+ySXXbZJTvttFOWLVuWyy+/vK1rBABgI8lpAACVS1YDAAAAgM3TY3OeNGzYsPz617/Orbfemt/97ndJkj322COjRo1q0+IAANg0choAQOWS1QAAAABg82zSldxuu+227Lnnnlm2bFmqqqryV3/1V/nUpz6VT33qUznooIOy11575X//93/bq1YAANZDTgMAqFyyGgAAAABsmU0a5HbZZZflzDPPTP/+/ddZN2DAgPy///f/cumll7ZZcQAAbBw5DYByGz++NAHrktUAAAAAYMts0iC3Bx98MGPHjl3v+tGjR2f+/PlbXBQAdBerqmvztff+LF9778+yqrq23OXQibVHTrvzzjszfvz4DB06NFVVVbn++utbrD/ttNNSVVXVYnprDS+99FJOPvnk9O/fPwMHDswZZ5yR5cuXb1IdALxFbW3ys5+Vplr5AToDfWpsNG08AAAAQKt6bMrGS5YsSc+ePde/sx498vzzz29xUQDQXTRV98hdQz9a7jLoAtojp61YsSL77bdf/vZv/zbHHXdcq9uMHTs206dPb35c+5Y/xJ188sl59tlnc8stt2TVqlU5/fTTc9ZZZ2XmzJmbVAsAb9KjR/JR+QE6E31qbDRtPAAAAECrNmmQ2w477JCHH34473rXu1pd/9vf/jZDhgxpk8IAANh47ZHTxo0bl3Hjxr3tNrW1tamvr2913WOPPZbZs2fn/vvvz4EHHpgkufzyy3PUUUflkksuydChQzepHgCAzkqfGkDnNX58MmtWuasAAABgk25XetRRR+XLX/5yXn/99XXWvfbaazn//PPz13/9121WHAB0ddVNq3PwM9fm4GeuTXXT6nKXQydWrpw2d+7cDB48OLvttlvOPvvsvPjii83r5s2bl4EDBzYPcEuSUaNGpbq6Ovfee2+r+2tsbMyyZctaTAC8xerVybXXlqbV8gN0BvrU2GjaeAAAAIBWbdKV3M4999xcd9112XXXXTNp0qTstttuSZLf/e53mTZtWtasWZMvfelL7VIoAHRFPZsa80+//liS5CNjl6exepN+NUOzcuS0sWPH5rjjjstOO+2UhQsX5otf/GLGjRuXefPmpaamJg0NDRk8eHCL5/To0SODBg1KQ0NDq/ucOnVqLrzwwjatE6DLaWxMPlbKD1m+vHRrO6Ci6VNjo2njAQAAAFq1Sb0kdXV1ufvuu3P22WdnypQpKYoiSVJVVZUxY8Zk2rRpqaura5dCAQBYv3LktBNPPLF5fp999sm+++6bXXbZJXPnzs2RRx65WfucMmVKJk+e3Px42bJlGTZs2BbXCgBQTvrUAAAAAGDLbPJXAXfcccfcdNNN+b//+7888cQTKYoi7373u7PNNtu0R30AAGykcue0nXfeOdttt12eeOKJHHnkkamvr89zzz3XYpvVq1fnpZdeSn19fav7qK2tTW1tbUeUCwDQocqd1QAAAACgM9vs691vs802Oeigg9qyFgAA2kC5ctqf/vSnvPjiixkyZEiSZOTIkXn55Zczf/78HHDAAUmS2267LU1NTRkxYkSH1wcA7W38+HJXQGegTw3oyvwuBAAAoL1s9iA3AOANb+7EnTWrfHVAW1q+fHmeeOKJ5seLFi3KggULMmjQoAwaNCgXXnhhjj/++NTX12fhwoX5/Oc/n3e9610ZM2ZMkmSPPfbI2LFjc+aZZ+aKK67IqlWrMmnSpJx44okZOnRouQ4LAAAAAAAA6GSqy10AAACV6YEHHsh73vOevOc970mSTJ48Oe95z3ty3nnnpaamJr/97W/z4Q9/OLvuumvOOOOMHHDAAfnf//3fFrcbveqqq7L77rvnyCOPzFFHHZUPfvCD+f73v1+uQwIA6BLuvPPOjB8/PkOHDk1VVVWuv/76FutPO+20VFVVtZjGjh3bYpuXXnopJ598cvr375+BAwfmjDPOyPLlyzvwKAAAAABg45V1kJsOOQCAynXYYYelKIp1phkzZqRPnz65+eab89xzz2XlypV56qmn8v3vfz91dXUt9jFo0KDMnDkzr7zySpYuXZorr7wyW221VZmOCACga1ixYkX222+/TJs2bb3bjB07Ns8++2zz9NOf/rTF+pNPPjmPPPJIbrnlltx444258847c9ZZZ7V36QAAAACwWcp6u9K1HXJ/+7d/m+OOO67VbcaOHZvp06c3P37zlUGSUofcs88+m1tuuSWrVq3K6aefnrPOOiszZ85s19oBoC2sru6Vy/ab3jwPALBBvXola/+f3Et+gO5o3LhxGTdu3NtuU1tbm/r6+lbXPfbYY5k9e3buv//+HHjggUmSyy+/PEcddVQuueQSt5YvJ208ndT48eWuAAAAgK6urIPcdMgB0N2tqe6ZOcNOK3cZAEBn0rNnctpp5a4CqHBz587N4MGDs8022+SII47IV77ylWy77bZJknnz5mXgwIHN/WlJMmrUqFRXV+fee+/N3/zN37S6z8bGxjQ2NjY/XrZsWfseRHekjQcAAABoVVlvV7ox1nbI7bbbbjn77LPz4osvNq/bUIfc+jQ2NmbZsmUtJgBoD+PH+zYzAADQscaOHZt///d/z5w5c/Iv//IvueOOOzJu3LisWbMmSdLQ0JDBgwe3eE6PHj0yaNCgNDQ0rHe/U6dOzYABA5qnYcOGtetxAAAAAMBaZb2S24aMHTs2xx13XHbaaacsXLgwX/ziFzNu3LjMmzcvNTU1W9Qhd+GFF7Z3+QCwQdVNq/Pe529Okvx6+zFpqq7oX80AQCVYvTq5uZQfMmZM0kN+AFo68cQTm+f32Wef7Lvvvtlll10yd+7cHHnkkZu93ylTpmTy5MnNj5ctW2agW1vTxgMAAAC0qqJ7SXTIAdDV9WxqzPn3/3WS5CNjl6exmw9ye/NV72bNKl8dAFDRGhuTvy7lhyxfbgAEsEE777xztttuuzzxxBM58sgjU19fn+eee67FNqtXr85LL72U+vr69e6ntrY2tbW17V1u96aNBwAAAGhVxd+u9M3e3CGXZIs65Pr3799iAgAAAICu6E9/+lNefPHFDBkyJEkycuTIvPzyy5k/f37zNrfddluampoyYsSIcpUJAAAAAOvVqQa56ZADAAAAoLtbvnx5FixYkAULFiRJFi1alAULFmTx4sVZvnx5zjnnnNxzzz156qmnMmfOnBxzzDF517velTFjxiRJ9thjj4wdOzZnnnlm7rvvvtx1112ZNGlSTjzxxAwdOrSMRwYAAAAArSvr9e6XL1/efFW25I0OuUGDBmXQoEG58MILc/zxx6e+vj4LFy7M5z//+fV2yF1xxRVZtWqVDjkA6CLcuhQAAFr3wAMP5PDDD29+PHny5CTJhAkT8r3vfS+//e1v8+Mf/zgvv/xyhg4dmtGjR+fiiy9ucavRq666KpMmTcqRRx6Z6urqHH/88fn2t7/d4ccCAAAAABujrIPcdMgBAAAAwKY57LDDUhTFetfffPPNG9zHoEGDMnPmzLYsCwCA9Zg2bVr+9V//NQ0NDdlvv/1y+eWX533ve98Gn3f11VfnpJNOyjHHHJPrr7++/QsFAKhgZR3kpkMOAAAAOrc3X30VAACAlq655ppMnjw5V1xxRUaMGJHLLrssY8aMyeOPP57Bgwev93lPPfVUPve5z+WQQw7pwGoBACpXdbkLAICuZvz4NyYAAAAAALqvSy+9NGeeeWZOP/307LnnnrniiivSt2/fXHnllet9zpo1a3LyySfnwgsvzM4779yB1QIAVK6yXskNALq71dW98r29v9M8DwCwQb16Jd/5zhvzAHQd2ngA6FJWrlyZ+fPnZ8qUKc3LqqurM2rUqMybN2+9z7vooosyePDgnHHGGfnf//3fjigVAKDiGeQGAGW0prpnbho+sdxlAACdSc+eyUT5AaBL0sYDQJfywgsvZM2aNamrq2uxvK6uLr/73e9afc6vfvWr/OhHP8qCBQs2+nUaGxvT2NjY/HjZsmWbVS8AQCVzu1IAAACAduAW9gAAwKZ45ZVXcsopp+QHP/hBtttuu41+3tSpUzNgwIDmadiwYe1YJQBAebiSGwCUUXWxJnu+WLrc/KPbHpKmqpoyVwQAVLw1a5K1t6s55JCkRn4A6DK08QDQpWy33XapqanJkiVLWixfsmRJ6uvr19l+4cKFeeqppzL+Td+WaWpqSpL06NEjjz/+eHbZZZd1njdlypRMnjy5+fGyZcsMdAMAuhyD3ACgjHqueT1T7zk8SfKRscvT2KNfmSsCACre668nh5fyQ5YvT/rJDwBdhjYeALqUXr165YADDsicOXNy7LHHJikNWpszZ04mTZq0zva77757HnrooRbLzj333Lzyyiv51re+td6Ba7W1tamtrW3z+gEAKolBbgAAAMAmcQtOAACAjTN58uRMmDAhBx54YN73vvflsssuy4oVK3L66acnSU499dTssMMOmTp1anr37p299967xfMHDhyYJOssBwDobgxyAwAAAAAANsnaQe+zZpW3DoBKd8IJJ+T555/Peeedl4aGhuy///6ZPXt26urqkiSLFy9OdXV1masEAKh8BrkBAAAAAAAAtJNJkya1envSJJk7d+7bPnfGjBltXxAAQCfkawEAAAAAAAAAAABULIPcAAAAAAAAAAAAqFgGuQEAAAAAAAAAAFCxepS7AADoztZU98yVe3y9eR4AYIN69ky+/vU35gHoOrTxAAAAAK0yyA0AtsD48Vv2/NXVvfLzXc5pm2IAgO6hV6/kHPkBoEvSxgMAAAC0yu1KAQAAAAAAAAAAqFiu5AYAZVRdrMkuS3+dJFk44L1pqqopc0UAQMVbsyb5dSk/5L3vTWrkB4AuQxsPAAAA0CqD3ACgjHqueT2X/up9SZKPjF2exh79ylwRAFDxXn89eV8pP2T58qSf/ADQZWjjAQAAAFrldqUAAAAAAAAAAABULIPcAAAAAAAAAAAAqFgGuQEAAAAAAAAAAFCxDHIDAAAAAAAAAACgYvUodwEAAAAAXdn48W/Mz5pVvjoAAAAAADorV3IDAAAAAAAAAACgYrmSGwCU0Zrqnpn57vOb5wEANqhnz+T889+YB6Dr0MYDAAAAtMogNwAoo9XVvfLT3S4odxkAQGfSq1dywQVleek333YTgHZQxjYeAAAAoJK5XSkAAAAAALBZDIIHAACgI7iSGwCUUVXRlGHLH0uSPL3VHimqjD8HADagqSl5rJQfssceSbX8ANBlaOMBAAAAWmWQGwCUUa81r2XaHXsnST4ydnkae/Qrc0UAQMV77bVk71J+yPLlST/5AaDL0MZDRVp7tbpZs1p/DAAAQPszyA0AAAB4W25DBgCsJRcAAABQDq53DwAAAAAAAAAAQMUyyA0AAAAAAAAAAICKZZAbAAAAAAAAAAAAFcsgNwAAAAAAAAAAACqWQW4AAAAAAAAAAABUrB7lLgAAurM11T1z3c6fa54HANignj2Tz33ujXkAug5tPAAAAECrDHIDgDJaXd0r0/f813KXAQB0Jr16Jf8qPwB0Sdp4AAAAgFa5XSkAAK268847M378+AwdOjRVVVW5/vrrW6wviiLnnXdehgwZkj59+mTUqFH5wx/+0GKbl156KSeffHL69++fgQMH5owzzsjy5cs78CgAAACgbYwfX5oAAADoeAa5AUAZVRVNGfzqUxn86lOpKprKXQ60sGLFiuy3336ZNm1aq+u//vWv59vf/nauuOKK3HvvvenXr1/GjBmT119/vXmbk08+OY888khuueWW3Hjjjbnzzjtz1llnddQhAHRNTU3JU0+Vpib5AaBL0cYDAAAAtMrtSgGgjHqteS0/um2nJMlHxi5PY49+Za4I3jBu3LiMGzeu1XVFUeSyyy7Lueeem2OOOSZJ8u///u+pq6vL9ddfnxNPPDGPPfZYZs+enfvvvz8HHnhgkuTyyy/PUUcdlUsuuSRDhw7tsGMB6FJeey3ZqZQfsnx50k9+AOgytPEAAAAArXIlNwAANtmiRYvS0NCQUaNGNS8bMGBARowYkXnz5iVJ5s2bl4EDBzYPcEuSUaNGpbq6Ovfee2+H1wwAAMCmc4tOAAAAKoEruQEAFW9tZ/qsWeWtgzc0NDQkSerq6losr6ura17X0NCQwYMHt1jfo0ePDBo0qHmbt2psbExjY2Pz42XLlrVl2QAAAAAAAEAn5EpuAECnsfbb475B3nVNnTo1AwYMaJ6GDRtW7pIAAAAAAACAMjPIDQCATVZfX58kWbJkSYvlS5YsaV5XX1+f5557rsX61atX56WXXmre5q2mTJmSpUuXNk9PP/10O1QPwMYyuBwq05133pnx48dn6NChqaqqyvXXX99ifVEUOe+88zJkyJD06dMno0aNyh/+8IcW27z00ks5+eST079//wwcODBnnHFGli9f3oFHAQAAAAAbr6yD3HTIAQB0TjvttFPq6+szZ86c5mXLli3Lvffem5EjRyZJRo4cmZdffjnz589v3ua2225LU1NTRowY0ep+a2tr079//xYTAAAtrVixIvvtt1+mTZvW6vqvf/3r+fa3v50rrrgi9957b/r165cxY8bk9ddfb97m5JNPziOPPJJbbrklN954Y+68886cddZZHXUIAAAAALBJyjrITYccAEDlWr58eRYsWJAFCxYkSRYtWpQFCxZk8eLFqaqqymc+85l85StfyQ033JCHHnoop556aoYOHZpjjz02SbLHHntk7NixOfPMM3PfffflrrvuyqRJk3LiiSdm6NCh5TswAIBObty4cfnKV76Sv/mbv1lnXVEUueyyy3LuuefmmGOOyb777pt///d/zzPPPNP8BdPHHnsss2fPzg9/+MOMGDEiH/zgB3P55Zfn6quvzjPPPNPBRwMAAAAAG9ajnC8+bty4jBs3rtV1b+2QS5J///d/T11dXa6//vqceOKJzR1y999/fw488MAkyeWXX56jjjoql1xyiT+eAlDx1lT1yC92/GTzPFSSBx54IIcffnjz48mTJydJJkyYkBkzZuTzn/98VqxYkbPOOisvv/xyPvjBD2b27Nnp3bt383OuuuqqTJo0KUceeWSqq6tz/PHH59vf/naHHwtAl9KjR/LJT74xD/AmixYtSkNDQ0aNGtW8bMCAARkxYkTmzZuXE088MfPmzcvAgQOb+9OSZNSoUamurs69997b6uA5Oog2HgAAAKBVFdtT0p4dco2NjWlsbGx+vGzZsvY7EAB4G6tranPFPq1f0RTK7bDDDktRFOtdX1VVlYsuuigXXXTRercZNGhQZs6c2R7lAXRftbXJeq6IDtDQ0JAkqaura7G8rq6ueV1DQ0MGDx7cYn2PHj0yaNCg5m1ao0+tA2jjAQAAAFpV1tuVvp327JCbOnVqBgwY0DwNGzasjasHoCsbP/6NCQAAoLvQpwYAAABAuVTsILf2NGXKlCxdurR5evrpp8tdEgDdVVGkf+Pz6d/4fPI2V8wCAGhWFMnzz5cm+QF4i/r6+iTJkiVLWixfsmRJ87r6+vo899xzLdavXr06L730UvM2rdGn1gG08QAAAACtqthBbu3ZIVdbW5v+/fu3mACgHGrXvJqrbhmcq24ZnNo1r5a7HACgM3j11WTw4NL0qvzQ2bgiMO1tp512Sn19febMmdO8bNmyZbn33nszcuTIJMnIkSPz8ssvZ/78+c3b3HbbbWlqasqIESPWu299ah1AG08F8zsMAACAcqrYQW7t2SEHAAAAAJ3V8uXLs2DBgixYsCBJsmjRoixYsCCLFy9OVVVVPvOZz+QrX/lKbrjhhjz00EM59dRTM3To0Bx77LFJkj322CNjx47NmWeemfvuuy933XVXJk2alBNPPDFDhw4t34EBAAAAwHr0KOeLL1++PE888UTz47UdcoMGDco73/nO5g65d7/73dlpp53y5S9/eb0dcldccUVWrVqlQw6AduGbygAAQKV44IEHcvjhhzc/njx5cpJkwoQJmTFjRj7/+c9nxYoVOeuss/Lyyy/ngx/8YGbPnp3evXs3P+eqq67KpEmTcuSRR6a6ujrHH398vv3tb3f4sQCVaW0/yKxZ5a0DAAAA1irrIDcdcgAAAACwaQ477LAURbHe9VVVVbnoooty0UUXrXebQYMGZebMme1RHgAAAAC0ubIOctMhBwAAAAAAAAAAwNupLncBAAAAAAAAAAAAsD4GuQEAAAAAAGyi8eNLEwAAAO2vrLcrBYDubk1Vj8x5x4TmeQCADerRI5kw4Y35NrT2j7SzZrXpbgHYWO3YxgMAAAB0ZnpKAKCMVtfU5rL9Z5S7DACgM6mtTWbMKHcVALQHbTwAAABAq9yuFAAAAAAAWIdbcQIAAFApXMkNAMqpKFK75tUkSWNN36SqqswFAQAVryiSV0v5IX3lB4AuRRsPAAAA0CqD3ACgjGrXvJr/nL1VkuQjY5ensUe/MlfUebz52+SzZpWvDgDocK++mmxVyg9ZvjzpJz8AdBnaeAAAAIBWuV0pAAAAAAAAAAAAFcsgNwAAAIAONn58yyvTAgAAAACwfm5XCgBv4TaYAAAAAAAAAFA5DHIDgLfh6hoAAAAAAAAAUF5uVwpAt+Y2UQAAlJM8CgAAAACwYQa5AQAAAAAAAAAAULHcrhQAyqipqia/GvKR5nkAgA2qqUk+8pE35gHoOrTxAAAAAK0yyA0AymhVTe/8ywHXlrsMAKAz6d07uVZ+AOiStPEAAAAArXK7UgAAAAAAAAAAACqWQW4AAAAAAAAAAABULLcrBYAyql29Iv85e6skyUfGLk9jj35lrggAqHgrViRblfJDli9P+rV9fhg/vs13CcDG6IA2HgAAAKAzciU3AAAAAAAAAAAAKpYruQEAAEA35qptAMBacgEAAACVypXcAAAAAAAAAAAAqFgGuQEAAAAAAGwmV8ADNmTatGkZPnx4evfunREjRuS+++5b77Y/+MEPcsghh2SbbbbJNttsk1GjRr3t9gAA3YVBbgBApzd+vA5lAKBzk2cAAKBruuaaazJ58uScf/75+fWvf5399tsvY8aMyXPPPdfq9nPnzs1JJ52U22+/PfPmzcuwYcMyevTo/PnPf+7gygEAKotBbgAAAAAAAADt4NJLL82ZZ56Z008/PXvuuWeuuOKK9O3bN1deeWWr21911VX55Cc/mf333z+77757fvjDH6apqSlz5szp4MoBACpLj3IXAADdWVNVTe4ffFTzPADABtXUJEcd9cY8AF2HNh4AupSVK1dm/vz5mTJlSvOy6urqjBo1KvPmzduofbz66qtZtWpVBg0atN5tGhsb09jY2Px42bJlm180AECFMsgNAMpoVU3vXPS+X5S7DACgM+ndO/mF/ADQJWnjAaBLeeGFF7JmzZrU1dW1WF5XV5ff/e53G7WPL3zhCxk6dGhGjRq13m2mTp2aCy+8cItqBQCodG5XCgAAAAAAAFBhvva1r+Xqq6/Oz3/+8/Tu3Xu9202ZMiVLly5tnp5++ukOrBIAoGO4khsA3c748eWuAAAAAACArm677bZLTU1NlixZ0mL5kiVLUl9f/7bPveSSS/K1r30tt956a/bdd9+33ba2tja1tbVbXC8AQCVzJTcAKKPa1Sty7f/0y7X/0y+1q1eUuxwAoDNYsSLp1680rZAfALoUbTwAdCm9evXKAQcckDlz5jQva2pqypw5czJy5Mj1Pu/rX/96Lr744syePTsHHnhgR5QKAFDxXMkNAMqs95pXy10CANDZvCo/AHRZ2ngA6FImT56cCRMm5MADD8z73ve+XHbZZVmxYkVOP/30JMmpp56aHXbYIVOnTk2S/Mu//EvOO++8zJw5M8OHD09DQ0OSZKuttspWW21VtuMAACg3g9wAAAAAAAAA2sEJJ5yQ559/Puedd14aGhqy//77Z/bs2amrq0uSLF68ONXVb9x863vf+15WrlyZj3zkIy32c/755+eCCy7oyNIBACqKQW4AkGT8+HJXAAAAAABAVzRp0qRMmjSp1XVz585t8fipp55q/4IAADohg9wAAACgGzLIHwAAAACAzsIgNwAAAAAA6MYMfgcAAKDSVW94EwAAAAAAAAAAACgPV3IDgDIqqqrz0KAPNc8DAGxQdXXyoQ+9Mb+JXKkFoIJtYRsPlM/ajDVrVnnrAAAA6KoMcgOAMlpZ0ydf/MDccpcBAHQmffokc+eWuwoA2oM2HgAAAKBVBrkBAAAAVIg3X2nPlWAAaG+u8AoAAEBn4Zr3AAAAAAAAAAAAVCxXcgOgW6jUbybXrl6RH902PElyxhFPpbFHv/IWBABUvhUrkuHDS/NPPZX0kx8AugxtPAAAAECrXMkNAMpswMoXMmDlC+Uuo0sYP/6NifZ3wQUXpKqqqsW0++67N69//fXXM3HixGy77bbZaqutcvzxx2fJkiVlrBigC3nhhdIEQNejjQcAAABYh0FuAABstr322ivPPvts8/SrX/2qed1nP/vZzJo1K9dee23uuOOOPPPMMznuuOPKWC0AAAC0L1++AwAAaB9uVwoAwGbr0aNH6uvr11m+dOnS/OhHP8rMmTNzxBFHJEmmT5+ePfbYI/fcc0/e//73d3SpAN2eP7YCQPe2NgvMmlXeOgAAAGBzVPSV3NwCCwCgsv3hD3/I0KFDs/POO+fkk0/O4sWLkyTz58/PqlWrMmrUqOZtd99997zzne/MvHnz1ru/xsbGLFu2rMUEAMCm0acGAAAAQFdT0YPcErfAAgCoVCNGjMiMGTMye/bsfO9738uiRYtyyCGH5JVXXklDQ0N69eqVgQMHtnhOXV1dGhoa1rvPqVOnZsCAAc3TsGHD2vkoAAC6Jn1qAAAAAHQlFX+7UrfAAgA2h9uwtL9x48Y1z++7774ZMWJEdtxxx/zsZz9Lnz59NmufU6ZMyeTJk5sfL1u2zEA3AIDNoE8NWMstywEAAOgKKv5Kbm19CywAqCRFVXX+MODA/GHAgSmqKv7XMrytgQMHZtddd80TTzyR+vr6rFy5Mi+//HKLbZYsWdLqH1vXqq2tTf/+/VtMALxFdXVy4IGlqVp+AFrXHn1qbi3fAbTxdACD3gAAAOiMKrqnpD1ugZXokAOgcqys6ZPJh9yfyYfcn5U1m3flK6gUy5cvz8KFCzNkyJAccMAB6dmzZ+bMmdO8/vHHH8/ixYszcuTIMlYJ0AX06ZPcf39p2swrZwJdW3v1qbm1fAfQxgMAAAC0qqJvV9oet8BKSh1yF154YVuUCADQbX3uc5/L+PHjs+OOO+aZZ57J+eefn5qampx00kkZMGBAzjjjjEyePDmDBg1K//7986lPfSojR450CywAgHbWXn1qbi0PAAAAQLlU9JXc3qotboGVlDrkli5d2jw9/fTT7Vg1AEDX9Kc//SknnXRSdtttt3zsYx/Ltttum3vuuSfbb799kuSb3/xm/vqv/zrHH398Dj300NTX1+e6664rc9UAAN1PW/WpubU8dB3jx7ttKQAAAJ1Lpxrk1la3wNIhB0ClqF3zan44Z3h+OGd4ate8Wu5yYJNcffXVeeaZZ9LY2Jg//elPufrqq7PLLrs0r+/du3emTZuWl156KStWrMh11123wT+cArARXn01GT68NL0qP3RlBiDQVtxWvhPRxgMAAAC0qqJvV+oWWAB0eUWRutf+2DwPALBBRZH8UX4A1k+fWiemjQcAAABoVUUPclt7C6wXX3wx22+/fT74wQ+ucwus6urqHH/88WlsbMyYMWPy3e9+t8xVAwAAALSdtVdzmzWrvHXQeehTAwAAAKCrqehBbldfffXbrl97C6xp06Z1UEUAAADQubjdJXQ/+tQAKofB6gAAAG2jutwFAAAAAAAAAAAAwPoY5AYAAAAAAAAAAEDFMsgNAAAAAAAAAACAitWj3AUAQLdWVZXFW+3ZPA8AsEFVVcme8gNAl6SNBwAAAGiVQW4AUEaNNX0z8bBHyl0GANCZ9O2bPCI/dEfjx5f+nTWrvHUA7UgbD13G2t/bAAAAtA2D3AAAAAAAoIsxyAoAAICuxCA3AAAAAADoIgxuAwAAoCsyyA2ALq3SO3Zr17yaS//3oCTJ5EPuT2NN3zJXBABUvFdfTQ4q5Yfcf3/p1nYAdA3aeAAAAIBWGeQGAOVUFHnn8keb5wEANqgokkdb5oe1A/tnzSpTTQC0jVbaeAAAAAAMcgOgC6r0q7dRPm/+bBgEAEBXJg8BAAAAANCVGOQGAAAAndRHPpI0vul/9ga3AQAAAADQFRnkBkCn5spcAAAAAAAAANC1VZe7AAAAAAAAAAAAAFgfg9wAAAAAAAAAAACoWG5XCkCX8eZbl3YaVVVZ0mfH5nkAgA2qqkp2lB+6s7W5d9as8tYBtANtPAAAAECrDHIDoNPplIPZ1qOxpm/+7sinyl1Gl9aVPi8AkCTp2zd56qkkSaPfcwBdy5vaeKBrGT/eAHUAAIAt4XalAAAAAADQBfiiFwAAAF2VK7kBAN3am/8A4BvVAAAAAAAAAJXHIDcAKKNea17L1+4+NEnyTx+4Mytr+pS5IgCg4r32WnJoKT/02l5+AOhS3tTG5847kz7aeDaOK7gBAADQ1RnkBgBlVFU05d1LH2ieBwDYoKam5IG/5Iex8gNAl/KmNj5N2njoatYORnQleQAAgE1nkBsAFc2tJGkvvuUOAAAAAAAA0DlUl7sAAAAAAAAAAAAAWB9XcgOg03DlLQAAAAAAAADofgxyAwAAAACATsgXAgEAAOgu3K4UAAAAAAAAAACAiuVKbgBQZkt7bVfuEgCACrT2yiyzZq27Tn4A6MK208YDAAAAvJVBbgCU1Ztvq9HaH3C7usYe/fKJ0c+XuwwAoJMoZad+ifwA0DX165c8r42Hru7tvswAAABA6wxyA6Bi6OADAFjXm78UAAAAAAAA3ZFBbgBUHH/IBQAAAAAAAADWMsgNAMqo15rXcsG945IkF4z4n6ys6VPmigCAjvbWAf4buqqt/ADQhb32WjKu1Mbnf/4n6aONBwAAAEgMcgOAsqoqmrLPS3c0zwMAbOiqtvIDa639rGxoYCTQiTQ1JXfc8cY8AAAAAEmS6nIXAAAAAAAAbLzx4zc8MJ7K99b30XsKAACwfq7kBgAAANCJvfkP4q7qBtD1aOcBAADAldwAAAAAAAAAAACoYK7kBgDwF74dDwB0NWvzjWwD0DW4nSUAAADdlUFuAHQYf2ADAID2JXMDdB0GtAEAAMAbDHIDoF3pkN2w12v6lrsEAKCTkR8AurC+2vjuTl8KAAAArMsgNwAoo8Ye/fLRcSvKXQYA0InIDwBdWL9+yQptPHQ3BjYCAABsWHW5CwAAAAAAAAAAAID1cSU3AIC38eZvU8+aVb46AKhsa39fbOh3hd8rAEBrXMkLAAAA3p5BbgBstI39o6yO2Y3Xc83rmTL/+CTJ1AP+K6tqepe5IgCgo2xuZpIfALqw119Pji+18fmv/0p6a+MBAAAAEoPcACgDg+DeUF2syUHP3dQ8T+XwOQWgUskPbI6NvdogUGZr1iQ33fTGPAAAAABJDHIDYDP5IxndkVvMAfBmBkRTydb3+ZTjAbbM5raj63uePAEAAAAbp7rcBbSVadOmZfjw4endu3dGjBiR++67r9wlAXQ748frnKX78HnfNLIa0N35vQFUKjkN2p8MwOZ4a36UJ6Fz29TMde2112b33XdP7969s88+++SmtVd6BQDoxrrEldyuueaaTJ48OVdccUVGjBiRyy67LGPGjMnjjz+ewYMHl7s8gLLa0JWn1rd+YzvNdK4BGyKrAV3Fxly5RTais2jt/wGu8tb9yGmw8dr6d7zMwPq89bPR2mO/q6Fz2dTMdffdd+ekk07K1KlT89d//deZOXNmjj322Pz617/O3nvvXYYjAACoDF3iSm6XXnppzjzzzJx++unZc889c8UVV6Rv37658sory10aAEC3J6sBXY2raNDV+Yx3H3IaAED729TM9a1vfStjx47NOeeckz322CMXX3xx3vve9+Y73/lOB1cOAFBZOv0gt5UrV2b+/PkZNWpU87Lq6uqMGjUq8+bNK2NlAG/Ykj8SrX2uPzIBnZGsBgBQmeQ0aHtv7sPRn0N72tBny+cOKsfmZK558+a12D5JxowZI6MBAN1ep79d6QsvvJA1a9akrq6uxfK6urr87ne/a/U5jY2NaWxsbH68dOnSJMmyZcvar1CgW1u1qvTvm5uZj33sjfmf/Wz9y9Y+963Pb82bn9+asWM3fv9vXk77qV6zImtP+6rVy7KqWFPWeth0b/652pD1/ayvzSBFUbRhZZVhU7OanAZsirdmn7XtbGvr37puQ/uqZPIDbW3tr9m3/h/Ar9+SrprV9KlVqBUr3phftixZo43vSK1li/VlhNY+9hvTl7Ip/4eEDXnr5+nN/X2aZrqDzpDTNidzNTQ0tLp9Q0PDel9HTgMAKk17ZLVOP8htc0ydOjUXXnjhOsuHDRtWhmqA7mTAgI1fvrHL2rKWttw/G6/5tN86tJxl0AE29HP3yiuvZEA3/0GU04At8XZNaFdrXuUH2tKm/D+lO5PVZLUON1QbX27dKVvQNbz5c+kzSncip8lpAEDlevHFF9ssq3X6QW7bbbddampqsmTJkhbLlyxZkvr6+lafM2XKlEyePLn5cVNTU1566aVsu+22qaqqatd611q2bFmGDRuWp59+Ov379++Q16xEzkOJ81DiPJQ4DyXOQ4nzUNLVz0NRFHnllVcytAv+EWtTs5qcVjmchxLnocR5eINzUeI8lDgPJV39PHTVrKZPrXNzHkqchxLnocR5KHEeSpyHkq5+HjpDTtuczFVfX79J2yfr5rSXX345O+64YxYvXtztBwB2Jl39Z7Yr8p51Tt63zsd71jktXbo073znOzNo0KA222enH+TWq1evHHDAAZkzZ06OPfbYJKUOtjlz5mTSpEmtPqe2tja1tbUtlg0cOLCdK21d//79/RDGeVjLeShxHkqchxLnocR5KOnK56GrdjZtalaT0yqP81DiPJQ4D29wLkqchxLnoaQrn4eumNX0qXUNzkOJ81DiPJQ4DyXOQ4nzUNKVz0Ol57TNyVwjR47MnDlz8pnPfKZ52S233JKRI0eu93Vay2lJ6fx01fe+K+vKP7Ndlfesc/K+dT7es86purq6zfbV6Qe5JcnkyZMzYcKEHHjggXnf+96Xyy67LCtWrMjpp59e7tIAALo9WQ0AoDLJaQAA7W9DmevUU0/NDjvskKlTpyZJPv3pT+dDH/pQvvGNb+Too4/O1VdfnQceeCDf//73y3kYAABl1yUGuZ1wwgl5/vnnc95556WhoSH7779/Zs+enbq6unKXBgDQ7clqAACVSU4DAGh/G8pcixcvbnGFkw984AOZOXNmzj333Hzxi1/Mu9/97lx//fXZe++9y3UIAAAVoUsMckuSSZMmrfeyvpWotrY2559/fquXDu5OnIcS56HEeShxHkqchxLnocR56Pw6U1bzeStxHkqchxLn4Q3ORYnzUOI8lDgPnVtnymmJz9tazkOJ81DiPJQ4DyXOQ4nzUOI8VI63y1xz585dZ9lHP/rRfPSjH93s1/Ped07et87He9Y5ed86H+9Z59Qe71tVURRFm+0NAAAAAAAAAAAA2lD1hjcBAAAAAAAAAACA8jDIDQAAAAAAAAAAgIplkBsAAAAAAAAAAAAVyyC3NjJt2rQMHz48vXv3zogRI3Lfffetd9vrrrsuBx54YAYOHJh+/fpl//33z3/8x3+02Oa0005LVVVVi2ns2LHtfRhbbFPOw5tdffXVqaqqyrHHHttieVEUOe+88zJkyJD06dMno0aNyh/+8Id2qLxttfV56A6fhxkzZqxzjL17926xTWf9PCRtfy66w2ciSV5++eVMnDgxQ4YMSW1tbXbdddfcdNNNW7TPStDW5+GCCy5Y5/Ow++67t/dhbLFNOQ+HHXbYOsdYVVWVo48+unmbztxG0P5ktRJZrURWK5HVSuS0EjmtRE4rkdPoSHJaiZxWIqeVyGlvkNVKZLUSWa1EVmOtTf2ZuPbaa7P77rund+/e2WeffdZpF+gYm/K+/eAHP8ghhxySbbbZJttss01GjRrVKdrrrqatMyodoz3yE+1rU9+zyy67LLvttlv69OmTYcOG5bOf/Wxef/31DqqWJLnzzjszfvz4DB06NFVVVbn++us3+Jy5c+fmve99b2pra/Oud70rM2bM2LQXLdhiV199ddGrV6/iyiuvLB555JHizDPPLAYOHFgsWbKk1e1vv/324rrrriseffTR4oknniguu+yyoqamppg9e3bzNhMmTCjGjh1bPPvss83TSy+91FGHtFk29TystWjRomKHHXYoDjnkkOKYY45pse5rX/taMWDAgOL6668vHnzwweLDH/5wsdNOOxWvvfZaOx7JlmmP89AdPg/Tp08v+vfv3+IYGxoaWmzTGT8PRdE+56I7fCYaGxuLAw88sDjqqKOKX/3qV8WiRYuKuXPnFgsWLNjsfVaC9jgP559/frHXXnu1+Dw8//zzHXVIm2VTz8OLL77Y4vgefvjhoqamppg+fXrzNp21jaD9yWolslqJrFYiq5XIaSVyWomcViKn0ZHktBI5rUROK5HT3iCrlchqJbJaiazGWpv6WbjrrruKmpqa4utf/3rx6KOPFueee27Rs2fP4qGHHurgyru3TX3fPv7xjxfTpk0rfvOb3xSPPfZYcdpppxUDBgwo/vSnP3Vw5d1Xe2RU2l975Aba16a+Z1dddVVRW1tbXHXVVcWiRYuKm2++uRgyZEjx2c9+toMr795uuumm4ktf+lJx3XXXFUmKn//852+7/ZNPPln07du3mDx5cvHoo48Wl19++Tr9OhtikFsbeN/73ldMnDix+fGaNWuKoUOHFlOnTt3ofbznPe8pzj333ObHEyZM6HS/8DbnPKxevbr4wAc+UPzwhz9c55ibmpqK+vr64l//9V+bl7388stFbW1t8dOf/rRdjqEttPV5KIru8XmYPn16MWDAgPXur7N+Hoqi7c9FUXSPz8T3vve9Yueddy5WrlzZZvusBO1xHs4///xiv/32a+tS29WWvnff/OY3i6233rpYvnx5URSdu42g/clqJbJaiaxWIquVyGklclqJnFYip9GR5LQSOa1ETiuR094gq5XIaiWyWomsxlqb+ln42Mc+Vhx99NEtlo0YMaL4f//v/7VrnbS0pT/Dq1evLrbeeuvixz/+cXuVyFu0R0al/bVHbqB9bep7NnHixOKII45osWzy5MnFwQcf3K51sn4bM8jt85//fLHXXnu1WHbCCScUY8aM2ejXcbvSLbRy5crMnz8/o0aNal5WXV2dUaNGZd68eRt8flEUmTNnTh5//PEceuihLdbNnTs3gwcPzm677Zazzz47L774YpvX31Y29zxcdNFFGTx4cM4444x11i1atCgNDQ0t9jlgwICMGDFio85tObTHeVirO3weli9fnh133DHDhg3LMccck0ceeaR5XWf8PCTtcy7W6uqfiRtuuCEjR47MxIkTU1dXl7333jtf/epXs2bNms3eZ7m1x3lY6w9/+EOGDh2anXfeOSeffHIWL17crseyJdrivfvRj36UE088Mf369UvSedsI2p+sViKrlchqJbJaiZxWIqeVyGklchodSU4rkdNK5LQSOe0NslqJrFYiq5XIaqy1OZ+FefPmtdg+ScaMGeN97kBt8TP86quvZtWqVRk0aFB7lcmbtGdGpf20Z26gfWzOe/aBD3wg8+fPb76l6ZNPPpmbbropRx11VIfUzOZpizzSo62L6m5eeOGFrFmzJnV1dS2W19XV5Xe/+916n7d06dLssMMOaWxsTE1NTb773e/mr/7qr5rXjx07Nscdd1x22mmnLFy4MF/84hczbty4zJs3LzU1Ne12PJtrc87Dr371q/zoRz/KggULWl3f0NDQvI+37nPtukrTHuch6R6fh9122y1XXnll9t133yxdujSXXHJJPvCBD+SRRx7JO97xjk75eUja51wk3eMz8eSTT+a2227LySefnJtuuilPPPFEPvnJT2bVqlU5//zzN7v9Laf2OA9JMmLEiMyYMSO77bZbnn322Vx44YU55JBD8vDDD2frrbdu9+PaVFv63t133315+OGH86Mf/ah5WWdtI2h/slqJrFYiq5XIaiVyWomcViKnlchpdCQ5rUROK5HTSuS0N8hqJbJaiaxWIqux1uZ8FhoaGrzPZdYW7e8XvvCFDB06dJ0BArSP9sqotK/2yg20n815zz7+8Y/nhRdeyAc/+MEURZHVq1fn7//+7/PFL36xI0pmM60vjyxbtiyvvfZa+vTps8F9GORWJltvvXUWLFiQ5cuXZ86cOZk8eXJ23nnnHHbYYUmSE088sXnbffbZJ/vuu2922WWXzJ07N0ceeWSZqm47r7zySk455ZT84Ac/yHbbbVfucspmY89DV/88JMnIkSMzcuTI5scf+MAHsscee+Tf/u3fcvHFF5exso63MeeiO3wmmpqaMnjw4Hz/+99PTU1NDjjggPz5z3/Ov/7rv3arQLkx52HcuHHN2++7774ZMWJEdtxxx/zsZz/rkt8U+tGPfpR99tkn73vf+8pdCl2YrCarJbLam8lqJXJaiZxWIqetS06jI8hpcloip72ZnPYGWa1EViuR1dYlq0Hn9rWvfS1XX3115s6dm969e5e7HFohq3de8lPnM3fu3Hz1q1/Nd7/73YwYMSJPPPFEPv3pT+fiiy/Ol7/85XKXRzsyyG0LbbfddqmpqcmSJUtaLF+yZEnq6+vX+7zq6uq8613vSpLsv//+eeyxxzJ16tTmDrm32nnnnbPddtvliSeeqMj/bG/qeVi4cGGeeuqpjB8/vnlZU1NTkqRHjx55/PHHm5+3ZMmSDBkypMU+999//3Y4ii3XHudhl112Wed5Xe3z0JqePXvmPe95T5544okk6ZSfh6R9zkVruuJnYsiQIenZs2eLb9HuscceaWhoyMqVK9vk3Ha09jgPvXr1Wuc5AwcOzK677vq2n5ly2pL3bsWKFbn66qtz0UUXtVjeWdsI2p+sViKrlchqJbJaiZxWIqeVyGklchodSU4rkdNK5LQSOe0NslqJrFYiq5XIaqy1OZ+F+vr6TvVz3xVtyc/wJZdckq997Wu59dZbs++++7ZnmbxJR2VU2lZH5Qbazua8Z1/+8pdzyimn5O/+7u+SlL7AsmLFipx11ln50pe+lOrq6navm023vjzSv3//jbqKW5J4Z7dQr169csABB2TOnDnNy5qamjJnzpwW3xrbkKampjQ2Nq53/Z/+9Ke8+OKLLf6TUUk29Tzsvvvueeihh7JgwYLm6cMf/nAOP/zwLFiwIMOGDctOO+2U+vr6FvtctmxZ7r333k06tx2pPc5Da7ra56E1a9asyUMPPdR8jJ3x85C0z7loTVf8TBx88MF54oknmv8DkCS///3vM2TIkPTq1avN2t+O1B7noTXLly/PwoULu9TnYa1rr702jY2N+cQnPtFieWdtI2h/slqJrFYiq5XIaiVyWomcViKnlchpdCQ5rUROK5HTSuS0N8hqJbJaiaxWIqux1uZ8FkaOHNli+yS55ZZbvM8daHN/hr/+9a/n4osvzuzZs3PggQd2RKn8RUdlVNpWR+UG2s7mvGevvvrqOgPZ1g5SLIqi/Ypli7RJHinYYldffXVRW1tbzJgxo3j00UeLs846qxg4cGDR0NBQFEVRnHLKKcU//dM/NW//1a9+tfjlL39ZLFy4sHj00UeLSy65pOjRo0fxgx/8oCiKonjllVeKz33uc8W8efOKRYsWFbfeemvx3ve+t3j3u99dvP7662U5xo2xqefhrSZMmFAcc8wxLZZ97WtfKwYOHFj893//d/Hb3/62OOaYY4qddtqpeO2119rzULZIW5+H7vJ5uPDCC4ubb765WLhwYTF//vzixBNPLHr37l088sgjzdt0xs9DUbT9uegun4nFixcXW2+9dTFp0qTi8ccfL2688cZi8ODBxVe+8pWN3mclao/z8I//+I/F3Llzi0WLFhV33XVXMWrUqGK77bYrnnvuuQ4/vo21uW3lBz/4weKEE05odZ+dtY2g/clqJbJaiaxWIquVyGklclqJnFYip9GR5LQSOa1ETiuR094gq5XIaiWyWomsxlqb+lm46667ih49ehSXXHJJ8dhjjxXnn39+0bNnz+Khhx4q1yF0S5v6vn3ta18revXqVfznf/5n8eyzzzZPr7zySrkOodtpj6xO+2uP3ED72tT37Pzzzy+23nrr4qc//Wnx5JNPFr/85S+LXXbZpfjYxz5WrkPoll555ZXiN7/5TfGb3/ymSFJceumlxW9+85vij3/8Y1EURfFP//RPxSmnnNK8/ZNPPln07du3OOecc4rHHnusmDZtWlFTU1PMnj17o1/TILc2cvnllxfvfOc7i169ehXve9/7invuuad53Yc+9KFiwoQJzY+/9KUvFe9617uK3r17F9tss00xcuTI4uqrr25e/+qrrxajR48utt9++6Jnz57FjjvuWJx55pkV/R/MtTblPLxVa7/km5qaii9/+ctFXV1dUVtbWxx55JHF448/3k7Vt522PA/d5fPwmc98pnnburq64qijjip+/etft9hfZ/08FEXbnovu8pkoiqK4++67ixEjRhS1tbXFzjvvXPzzP/9zsXr16o3eZ6Vq6/NwwgknFEOGDCl69epV7LDDDsUJJ5xQPPHEEx11OJttU8/D7373uyJJ8ctf/rLV/XXmNoL2J6uVyGolslqJrFYip5XIaSVyWomcRkeS00rktBI5rUROe4OsViKrlchqJbIaa23qZ+FnP/tZseuuuxa9evUq9tprr+IXv/hFB1dMUWza+7bjjjsWSdaZzj///I4vvBtr66xOx2iP/ET72pT3bNWqVcUFF1xQ7LLLLkXv3r2LYcOGFZ/85CeL//u//+v4wrux22+/vdXfU2vfqwkTJhQf+tCH1nnO/vvvX/Tq1avYeeedi+nTp2/Sa1YVhWv1AQAAAAAAAAAAUJmqN7wJAAAAAAAAAAAAlIdBbgAAAAAAAAAAAFQsg9wAAAAAAAAAAACoWAa5AQAAAAAAAAAAULEMcgMAAAAAAAAAAKBiGeQGAAAAAAAAAABAxTLIDQAAAAAAAAAAgIplkBsAAAAAAAAAAAAVyyA3YIs0NDTkr/7qr9KvX78MHDhwvcvaw4wZM9p1/91JVVVVrr/++o3efvjw4bnsssvarR4AoG3Ial2DrAYAXY+c1jXIaQAAAB3HIDdgvU477bRUVVWtM40dO7Z5m29+85t59tlns2DBgvz+979f77It1VoH0AknnNBm+387RVHk+9//fkaMGJGtttoqAwcOzIEHHpjLLrssr776aru/flu64IILsv/++6+z/Nlnn824ceM2ej/3339/zjrrrObHm9qhBwBsOVmtRFZbl6wGAOUlp5XIaeuS0wAAADZfj3IXAFS2sWPHZvr06S2W1dbWNs8vXLgwBxxwQN797ne/7bL20KdPn/Tp06ddXyNJTjnllFx33XU599xz853vfCfbb799HnzwwVx22WUZPnx4jj322Havob3V19dv0vbbb799O1UCAGwKWU1Wa42sBgDlJ6fJaa2R0wAAALZAAbAeEyZMKI455pj1rt9xxx2LJM3ThAkTWl1WFEXxf//3f8UZZ5xRbLfddsXWW29dHH744cWCBQta7O+GG24oDjzwwKK2trbYdttti2OPPbYoiqL40Ic+1GKfa5uu6dOnFwMGDCiKoigef/zxIknx2GOPtdjnpZdeWuy8887Njx966KFi7NixRb9+/YrBgwcXn/jEJ4rnn39+vcd4zTXXFEmK66+/fp11TU1Nxcsvv1wURVGsWbOmuPDCC4sddtih6NWrV7HffvsV//M//9O87aJFi4okxX/9138Vhx12WNGnT59i3333Le6+++7mbdYez+zZs4vdd9+96NevXzFmzJjimWeeafG6P/jBD4rdd9+9qK2tLXbbbbdi2rRpLdY//fTTxYknnlhss802Rd++fYsDDjiguOeee4rp06evcx6nT59eFEVRJCl+/vOfF0VRFCNHjiw+//nPt9jnc889V/To0aO44447iqIovfff/OY3m+ffvM8dd9yxWLRoUVFVVVXcf//9LfbzzW9+s3jnO99ZrFmzZr3nHADYOLKarLaWrAYAlUVOk9PWktMAAADajtuVApvt/vvvz9ixY/Oxj30szz77bL71rW+1uixJPvrRj+a5557L//zP/2T+/Pl573vfmyOPPDIvvfRSkuQXv/hF/uZv/iZHHXVUfvOb32TOnDl53/velyS57rrr8o53vCMXXXRRnn322Tz77LPr1LLrrrvmwAMPzFVXXdVi+VVXXZWPf/zjSZKXX345RxxxRN7znvfkgQceyOzZs7NkyZJ87GMfW+8xXnXVVdltt91yzDHHrLOuqqoqAwYMSJJ861vfyje+8Y1ccskl+e1vf5sxY8bkwx/+cP7whz+0eM6XvvSlfO5zn8uCBQuy66675qSTTsrq1aub17/66qu55JJL8h//8R+58847s3jx4nzuc59rUc95552Xf/7nf85jjz2Wr371q/nyl7+cH//4x0mS5cuX50Mf+lD+/Oc/54YbbsiDDz6Yz3/+82lqasoJJ5yQf/zHf8xee+3VfB5POOGEdY7r5JNPztVXX52iKJqXXXPNNRk6dGgOOeSQdba///77kyTTp0/Ps88+m/vvvz/Dhw/PqFGj1vnG8vTp03PaaaelutqvHwBob7KarJbIagBQieQ0OS2R0wAAADZZmQfZARVswoQJRU1NTdGvX78W0z//8z83b3PMMcc0f7N0fcv+93//t+jfv3/x+uuvt9hul112Kf7t3/6tKIrSNx1PPvnk9dby5m85rvXmb50WRekbjbvsskvz47d+E/Xiiy8uRo8e3WIfTz/9dJGkePzxx1t93T322KP48Ic/vN661ho6dGiL81IURXHQQQcVn/zkJ4uieONbpz/84Q+b1z/yyCMt6lv7rdAnnniieZtp06YVdXV1zY932WWXYubMmS1e5+KLLy5GjhxZFEVR/Nu//Vux9dZbFy+++GKrdZ5//vnFfvvtt87yvOlbp2u/YXrnnXc2rx85cmTxhS98ofnxW9+PNz9/rWuuuabYZpttmt/3+fPnF1VVVcWiRYtarQ0A2DSymqy2lqwGAJVFTpPT1pLTAAAA2o6v/QBv6/DDD8+CBQtaTH//93+/Sft48MEHs3z58my77bbZaqutmqdFixZl4cKFSZIFCxbkyCOP3KJaTzzxxDz11FO55557kpS+ofne9743u+++e3Mdt99+e4sa1q5bW8dbFW/65uX6LFu2LM8880wOPvjgFssPPvjgPPbYYy2W7bvvvs3zQ4YMSZI899xzzcv69u2bXXbZpcU2a9evWLEiCxcuzBlnnNHiGL7yla+0OI/vec97MmjQoA3WvT7bb799Ro8e3fwN3kWLFmXevHk5+eSTN2k/xx57bGpqavLzn/88STJjxowcfvjhGT58+GbXBgC0JKvJarIaAFQmOU1Ok9MAAADaVo9yFwBUtn79+uVd73rXFu1j+fLlGTJkSObOnbvOuoEDByZJ+vTps0WvkST19fU54ogjMnPmzLz//e/PzJkzc/bZZ7eoY/z48fmXf/mXdZ67tnPsrXbdddf87ne/2+La1urZs2fzfFVVVZKkqamp1fVrt1nbKbh8+fIkyQ9+8IOMGDGixXY1NTVJ2uY8JqXbK/zDP/xDLr/88sycOTP77LNP9tlnn03aR69evXLqqadm+vTpOe644zJz5szmW20AAG1DVpPVZDUAqExympwmpwEAALQtV3ID2t173/veNDQ0pEePHnnXu97VYtpuu+2SlL6NOWfOnPXuo1evXlmzZs0GX+vkk0/ONddck3nz5uXJJ5/MiSee2KKORx55JMOHD1+njn79+rW6v49//OP5/e9/n//+7/9eZ11RFFm6dGn69++foUOH5q677mqx/q677sqee+65wZo3Vl1dXYYOHZonn3xynfp32mmnJKXzuGDBgrz00kut7mNjz+MxxxyT119/PbNnz87MmTM3+I3Tnj17trrfv/u7v8utt96a7373u1m9enWOO+64jThSAKAjyWptQ1YDANqanNY25DQAAICuwSA34G01NjamoaGhxfTCCy9s0j5GjRqVkSNH5thjj80vf/nLPPXUU7n77rvzpS99KQ888ECS5Pzzz89Pf/rTnH/++Xnsscfy0EMPtfh26PDhw3PnnXfmz3/+89u+/nHHHZdXXnklZ599dg4//PAMHTq0ed3EiRPz0ksv5aSTTsr999+fhQsX5uabb87pp5++3k6qj33sYznhhBNy0kkn5atf/WoeeOCB/PGPf8yNN96YUaNG5fbbb0+SnHPOOfmXf/mXXHPNNXn88cfzT//0T1mwYEE+/elPb9K52pALL7wwU6dOzbe//e38/ve/z0MPPZTp06fn0ksvTZKcdNJJqa+vz7HHHpu77rorTz75ZP7rv/4r8+bNS1I6j4sWLcqCBQvywgsvpLGxsdXX6devX4499th8+ctfzmOPPZaTTjrpbesaPnx45syZk4aGhvzf//1f8/I99tgj73//+/OFL3whJ510Upt9KxYAKJHVZDVZDQAqk5wmp8lpAAAAbcsgN+BtzZ49O0OGDGkxffCDH9ykfVRVVeWmm27KoYcemtNPPz277rprTjzxxPzxj39MXV1dkuSwww7LtddemxtuuCH7779/jjjiiNx3333N+7jooovy1FNPZZdddsn222+/3tfaeuutM378+Dz44IPrfFNy7TdD16xZk9GjR2efffbJZz7zmQwcODDV1a03h1VVVZk5c2YuvfTSXH/99fnQhz6UfffdNxdccEGOOeaYjBkzJknyD//wD5k8eXL+8R//Mfvss09mz56dG264Ie9+97s36VxtyN/93d/lhz/8YaZPn5599tknH/rQhzJjxozmb5326tUrv/zlLzN48OAcddRR2WefffK1r32t+dYLxx9/fMaOHZvDDz8822+/fX7605+u97VOPvnkPPjggznkkEPyzne+823r+sY3vpFbbrklw4YNy3ve854W684444ysXLkyf/u3f7uFRw8AvJWsJqvJagBQmeQ0OU1OAwAAaFtVRVEU5S4CgK7r4osvzrXXXpvf/va35S4FAIC3kNUAACqTnAYAANCSK7kB0C6WL1+ehx9+ON/5znfyqU99qtzlAADwJrIaAEBlktMAAABaZ5AbAO1i0qRJOeCAA3LYYYe5rQIAQIWR1QAAKpOcBgAA0Dq3KwUAAAAAAAAAAKBiuZIbAAAAAAAAAAAAFcsgNwAAAAAAAAAAACqWQW4AAAAAAAAAAABULIPcAAAAAAAAAAAAqFgGuQEAAAAAAAAAAFCxDHIDAAAAAAAAAACgYhnkBgAAAAAAAAAAQMUyyA0AAAAAAAAAAICKZZAbAAAAAAAAAAAAFev/AwFEK3kN6c0mAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 2500x1500 with 12 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rules = (\n",
+    "    \"GKL\",\n",
+    "    \"GP\",\n",
+    "    \"GEP_1\",\n",
+    "    \"GEP_2\",\n",
+    "    \"Das\",\n",
+    "    \"Davis\",\n",
+    "    \"ABK\",\n",
+    "    \"DMC\",\n",
+    "    \"COE_1\",\n",
+    "    \"COE_2\",\n",
+    "    \"MM401\",\n",
+    ")\n",
+    "\n",
+    "\n",
+    "generated_nodes = {}\n",
+    "limit = 10000\n",
+    "shuffle = False\n",
+    "save = True\n",
+    "value_type = \"ke\"\n",
+    "\n",
+    "\n",
+    "# parallelize the loop\n",
+    "def worker(item):\n",
+    "    \"\"\"\n",
+    "    Worker function to be executed by each process.\n",
+    "    \"\"\"\n",
+    "    parent_node = BooleanNode.from_output_list(automata_output_list[item])\n",
+    "    node = BooleanNode.from_partial_lut(annihilation_gen# create 8 histogram subplots for the 8 rules\n",
+    "plot_hist(\n",
+    "    generated_node_values={k: v[plot_value_type] for k, v in generated_nodes.items()},\n",
+    "    value_type=plot_value_type,\n",
+    "    title=title,\n",
+    "    save=save,\n",
+    "    filename=filename,\n",
+    ")\n",
+    "# Use ProcessPoolExecutor to parallelize the loop\n",
+    "with ProcessPoolExecutor() as executor:\n",
+    "    results = executor.map(worker, rules)\n",
+    "\n",
+    "# Process results\n",
+    "for item, (nodes, bias, ke, count) in results:\n",
+    "    generated_nodes[item] = {\"nodes\": nodes, \"bias\": bias, \"ke\": ke, \"count\": count}\n",
+    "\n",
+    "\n",
+    "title = \"Distribution of $K_e$ of rules generated from anni_gen with parent rule bias.\"\n",
+    "filename = (\n",
+    "    \"Distribution of $K_e$ of rules generated from anni_gen with parent rule bias.png\"\n",
+    ")\n",
+    "\n",
+    "plot_hist(\n",
+    "    generated_node_values={k: v[value_type] for k, v in generated_nodes.items()},\n",
+    "    value_type=value_type,\n",
+    "    title=title,\n",
+    "    save=save,\n",
+    "    filename=filename,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plotting Bias of generated nodes from anni_gen rules with with parent rule $K_e$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rules = (\n",
+    "    \"GKL\",\n",
+    "    \"GP\",\n",
+    "    \"GEP_1\",\n",
+    "    \"GEP_2\",\n",
+    "    \"Das\",\n",
+    "    \"Davis\",\n",
+    "    # \"ABK\",\n",
+    "    \"DMC\",\n",
+    "    # # \"COE_1\",\n",
+    "    # \"COE_2\",\n",
+    "    \"MM401\",\n",
+    ")\n",
+    "\n",
+    "\n",
+    "generated_nodes = {}\n",
+    "# limit = 10000\n",
+    "shuffle = False\n",
+    "save = True\n",
+    "plot_value_type = \"bias\"\n",
+    "\n",
+    "\n",
+    "# parallelize the loop\n",
+    "def worker(item):\n",
+    "    \"\"\"\n",
+    "    Worker function to be executed by each process.\n",
+    "    \"\"\"\n",
+    "    if item in [\"GKL\",  \"GEP_1\", \"GEP_2\", \"Das\", \"MM401\",]:\n",
+    "        shuffle = False\n",
+    "        limit = 10000\n",
+    "    elif item in [\"Davis\", \"DMC\", \"COE_2\", \"GP\", \"ABK\"]:\n",
+    "        shuffle = True\n",
+    "        limit = 1000\n",
+    "    else:\n",
+    "        return None\n",
+    "    parent_node = BooleanNode.from_output_list(automata_output_list[item])\n",
+    "    node = BooleanNode.from_partial_lut(annihilation_generation[item])\n",
+    "    generator = node.generate_with_required_effective_connectivity(\n",
+    "        effective_connectivity=parent_node.effective_connectivity(),\n",
+    "        epsilon=0.01,\n",
+    "        shuffle=shuffle,\n",
+    "    )\n",
+    "\n",
+    "    return item, collect_data_from_generator(generator, limit=limit)\n",
+    "\n",
+    "\n",
+    "# Use ProcessPoolExecutor to parallelize the loop\n",
+    "with ProcessPoolExecutor() as executor:\n",
+    "    results = executor.map(worker, rules)\n",
+    "\n",
+    "# Process results\n",
+    "for item, (nodes, bias, ke, count) in results:\n",
+    "    if item is not None:\n",
+    "        generated_nodes[item] = {\"nodes\": nodes, \"bias\": bias, \"ke\": ke, \"count\": count}\n",
+    "\n",
+    "\n",
+    "title = \"Distribution of Bias of rules generated from anni_gen with parent rule $K_e$.\"\n",
+    "filename = (\n",
+    "    \"Distribution of Bias of rules generated from anni_gen with parent rule Ke.png\"\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "nodes ={k: v[plot_value_type] for k, v in generated_nodes.items()}\n",
+    "min_max, parent_rule_values = min_max_and_parent_rule_values(\n",
+    "    automata_output_list,\n",
+    "    nodes,\n",
+    "    value_type=\"bias\",\n",
+    "    include_parent=True,\n",
+    ")\n",
+    "save = True\n",
+    "# plot nodes in 8 subplots\n",
+    "fig, axs = plt.subplots(2, 4, figsize=(20, 10))\n",
+    "fig.suptitle(title)\n",
+    "for i, (item, node) in enumerate(nodes.items()):\n",
+    "    ax = axs[i // 4, i % 4]\n",
+    "    ax.hist(node, bins=100, color=\"blue\", alpha=0.7)\n",
+    "    ax.set_xlim(min_max)\n",
+    "    ax.text(\n",
+    "        0.2,\n",
+    "        0.9,\n",
+    "        f\"Total Count: {len(node)}\",\n",
+    "        horizontalalignment=\"center\",\n",
+    "        verticalalignment=\"center\",\n",
+    "        transform=ax.transAxes,\n",
+    "        fontsize=10,\n",
+    "    )\n",
+    "    ax.axvline(\n",
+    "        parent_rule_values[item],\n",
+    "        color=\"red\",\n",
+    "        linestyle=\"--\",\n",
+    "        label=f\"{item}: {parent_rule_values[item]:.2f}\",\n",
+    "    )\n",
+    "    ax.set_title(item)\n",
+    "    ax.set_xlabel(\"Bias\")\n",
+    "    ax.set_ylabel(\"Frequency\")\n",
+    "    ax.legend()\n",
+    "plt.tight_layout()\n",
+    "if save:\n",
+    "    plt.savefig(filename)\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/automata/automata_rules.py b/automata/automata_rules.py
new file mode 100644
index 0000000..7e93575
--- /dev/null
+++ b/automata/automata_rules.py
@@ -0,0 +1,1098 @@
+# sample automata rules for testing
+
+automata_output_list = {
+    "GKL": "00000000010111110000000001011111000000000101111100000000010111110000000001011111111111110101111100000000010111111111111101011111",
+    "GP": "00000101000000000101010100000101000001010000000001010101000001010101010111111111010101011111111101010101111111110101010111111111",
+    "GEP_1": "00010001000000000101010100000000000100010000111101010101000011110001000111111111010101011111111100010001111111110101010111111111",
+    "GEP_2": "00000000010101010000000001110111000000000101010100000000011101110000111101010101000011110111011111111111010101011111111101110111",
+    "Das": "00000111000000000000011111111111000011110000000000001111111111110000111100000000000001111111111100001111001100010000111111111111",
+    "Davis": "00000000001011110000001101011111000000000001111111001111000111110000000000101111111111000101111100000000000111111111111100011111",
+    "DMC": "00000101000001000000010110000111000001010000000000001111011101110000001101110111010101011000001101111011111111111011011101111111",
+    "COE_1": "00000001000101000011000011010111000100010000111100111001010101110000010110110100111111110001011111110001001111011111100101010111",
+    "COE_2": "00010100010100010011000001011100000000000101000011001110010111110001011100010001111111110101111100001111010100111100111101011111",
+    "MM401": "00010101000000000101010100000000000101010000000001010101000011110001010111111111010101011111111100010101111111110101010111111111",
+    "MM802": "00010100010100010000000011011100000011110001000000001110010111110001011100010001111111111101111100001111000100111100111101011111",
+    "F_WO_1": "00010100011000010000011101111100000011110000000011001110101111110001011100100001000001000111111100001111001100110011111110111111",
+    "F_WO_2": "00000010000000110011001100001111000000011101111101111011000101110000001010001100111111110000111111000001000111110111100111010111",
+    "F_WO_3": "00000011010100000100010000011111000000011100111111111000000011110000001101011100111101110001111100000001001111111111101100011111",
+    "F_WO_4": "00000111001000000000001101111111000001110001000011000101001111110000111111100000000011000111111100000111110111011111010100111111",
+    "F_WO_5": "00010000010000010100001100011100000000011101111111110000000011110001001101001101111111110001111100000001110111111111001100011111",
+    "F_WO_10": "00000111001000000000001101111111000001110001000011001101001111110000111111100000000011000111111100000111000111011111110100111111",
+    "F_WO_50": "00000000010111110100000000010111000000001111011100011000010001110000000001011111111100111101011111111100001101111101101101010111",
+    "F_WO_100": "00000010000000110011001100001111000000011101011101010011000101110000001010001100111111111100111111001101110101110101000111010111",
+    "F_WO_500": "00000111011000100100001101110011000101110001000011000100001011110000010001100010000011000111111100010111110111111111011100111111",
+    "F_WO_1000": "00000111011000000100001101111111000001110001000001000100001001110000011101100000000011000111111111000111110111110111011111110111",
+    "F_WO_3000": "00010001001100000111001010100000000101110101001100110011010011110001000100000011110011101010111100010111010111111100111101011111",
+    "F_WO_7000": "00010000000100110000010000011111000000011100111101011001000101110001101011011100111101110001111111000101001111010101100111010111",
+}
+autoschemata = {
+    "GKL": [
+        ["0##0###", 0],
+        ["##0#0#0", 0],
+        ["###10#0", 0],
+        ["##00###", 0],
+        ["0###0#0", 0],
+        ["1#1###1", 1],
+        ["1#10###", 1],
+        ["###11##", 1],
+        ["1#1#1##", 1],
+        ["###1##1", 1],
+    ],
+    "GP": [
+        ["###0##0", 0],
+        ["0#0#0##", 0],
+        ["0#####0", 0],
+        ["0#01###", 0],
+        ["0##10##", 0],
+        ["##1#1#1", 1],
+        ["1#####1", 1],
+        ["1##1###", 1],
+        ["##10##1", 1],
+        ["###01#1", 1],
+    ],
+    "GEP_1": [
+        ["0#0#00#", 0],
+        ["###0##0", 0],
+        ["00#1###", 0],
+        ["##00#0#", 0],
+        ["00####0", 0],
+        ["0##10##", 0],
+        ["000##0#", 0],
+        ["0###0#0", 0],
+        ["#1##111", 1],
+        ["1####11", 1],
+        ["#1#11##", 1],
+        ["##10##1", 1],
+        ["#11#1#1", 1],
+        ["1#1###1", 1],
+        ["1##1###", 1],
+        ["###0#11", 1],
+    ],
+    "GEP_2": [
+        ["0##0###", 0],
+        ["###1#00", 0],
+        ["#00#0#0", 0],
+        ["0#0###0", 0],
+        ["0####00", 0],
+        ["##01##0", 0],
+        ["#0##000", 0],
+        ["#0#00##", 0],
+        ["11#0###", 1],
+        ["111##1#", 1],
+        ["11####1", 1],
+        ["1##01##", 1],
+        ["1###1#1", 1],
+        ["##11#1#", 1],
+        ["1#1#11#", 1],
+        ["###1##1", 1],
+    ],
+    "Das": [
+        ["#010#00", 0],
+        ["0#0#0##", 0],
+        ["##01#0#", 0],
+        ["#001###", 0],
+        ["##011#0", 0],
+        ["##0#00#", 0],
+        ["#00#0##", 0],
+        ["000##00", 0],
+        ["###00##", 0],
+        ["0#01###", 0],
+        ["00#0#00", 0],
+        ["11##111", 1],
+        ["#1#01##", 1],
+        ["##1#1#1", 1],
+        ["#11#1##", 1],
+        ["##11###", 1],
+        ["11#101#", 1],
+        ["###011#", 1],
+        ["1#001##", 1],
+        ["11#1#11", 1],
+        ["###01#1", 1],
+        ["##1#11#", 1],
+    ],
+    "Davis": [
+        ["0##001#", 0],
+        ["00##000", 0],
+        ["#1#10#0", 0],
+        ["#00#0#1", 0],
+        ["###1000", 0],
+        ["##0#00#", 0],
+        ["##110#0", 0],
+        ["##00###", 0],
+        ["00#0#0#", 0],
+        ["10#011#", 0],
+        ["00#00##", 0],
+        ["001#0#0", 0],
+        ["#1#100#", 0],
+        ["#10#0#0", 0],
+        ["0#1#010", 0],
+        ["01##010", 0],
+        ["#001#10", 1],
+        ["111##11", 1],
+        ["101#0#1", 1],
+        ["##11#11", 1],
+        ["1110###", 1],
+        ["1#1#011", 1],
+        ["0#1#11#", 1],
+        ["###11##", 1],
+        ["1#10#0#", 1],
+        ["1#100##", 1],
+        ["#11#1##", 1],
+        ["1#1#10#", 1],
+        ["101##01", 1],
+        ["#011##1", 1],
+        ["#1#1#11", 1],
+        ["#110#0#", 1],
+    ],
+    "ABK": [
+        ["###0##0", 0],
+        ["0#0#0##", 0],
+        ["0#####0", 0],
+        ["0#01###", 0],
+        ["0##10##", 0],
+        ["##1#1#1", 1],
+        ["1#####1", 1],
+        ["1##1###", 1],
+        ["##10##1", 1],
+        ["###01#1", 1],
+    ],
+    "DMC": [
+        ["01#1#00", 0],
+        ["#0#00#0", 0],
+        ["#00##00", 0],
+        ["0#0###0", 0],
+        ["#01#010", 0],
+        ["##00000", 0],
+        ["01##000", 0],
+        ["1#10100", 0],
+        ["#0110#1", 0],
+        ["0##1100", 0],
+        ["#01101#", 0],
+        ["#0#0#00", 0],
+        ["101110#", 0],
+        ["00#0##0", 0],
+        ["00##0#1", 0],
+        ["#0##100", 0],
+        ["00##01#", 0],
+        ["#0000##", 0],
+        ["#110001", 0],
+        ["0#0#0##", 0],
+        ["0##00##", 0],
+        ["0#01#1#", 0],
+        ["1011#01", 0],
+        ["1#00101", 0],
+        ["1000#0#", 0],
+        ["#111000", 0],
+        ["#010##0", 0],
+        ["0101###", 0],
+        ["#011000", 1],
+        ["#111#1#", 1],
+        ["1#01##1", 1],
+        ["#001101", 1],
+        ["110#1#0", 1],
+        ["110#0#1", 1],
+        ["1###111", 1],
+        ["0##01#1", 1],
+        ["11###1#", 1],
+        ["#11#1#1", 1],
+        ["1#0#11#", 1],
+        ["#11#11#", 1],
+        ["1010##1", 1],
+        ["00##101", 1],
+        ["##1111#", 1],
+        ["11#1##1", 1],
+        ["0#1#1#1", 1],
+        ["##101#1", 1],
+        ["1##111#", 1],
+        ["01101##", 1],
+        ["11100#0", 1],
+        ["1101###", 1],
+        ["##1#111", 1],
+        ["11#11##", 1],
+        ["###0111", 1],
+        ["1#10#11", 1],
+        ["#111##1", 1],
+        ["1#01#1#", 1],
+    ],
+    "COE_1": [
+        ["101100#", 0],
+        ["#1#1000", 0],
+        ["01#10#0", 0],
+        ["1#11#00", 0],
+        ["#00111#", 0],
+        ["#1#0110", 0],
+        ["#0000##", 0],
+        ["#10010#", 0],
+        ["00101##", 0],
+        ["0#00##0", 0],
+        ["##11100", 0],
+        ["00#01#0", 0],
+        ["1#0#110", 0],
+        ["01010##", 0],
+        ["#0#1100", 0],
+        ["0#0#0#0", 0],
+        ["0##000#", 0],
+        ["#1110#0", 0],
+        ["#00#001", 0],
+        ["00##100", 0],
+        ["#00#1#0", 0],
+        ["0##0#01", 0],
+        ["1#110#0", 0],
+        ["##11010", 0],
+        ["##001#0", 0],
+        ["0##1010", 0],
+        ["01##000", 0],
+        ["#111#00", 0],
+        ["0#0#00#", 0],
+        ["10#1001", 0],
+        ["00#0#0#", 0],
+        ["000###0", 0],
+        ["0#00#0#", 0],
+        ["#000##0", 0],
+        ["0##0110", 0],
+        ["#1#0101", 0],
+        ["10##101", 1],
+        ["###1101", 1],
+        ["##11#11", 1],
+        ["#1#11#1", 1],
+        ["#110100", 1],
+        ["101#1#1", 1],
+        ["0#11##1", 1],
+        ["##1001#", 1],
+        ["1#1##11", 1],
+        ["#0#1011", 1],
+        ["01011##", 1],
+        ["1##1011", 1],
+        ["1010###", 1],
+        ["1#100##", 1],
+        ["#11##11", 1],
+        ["1##0111", 1],
+        ["11#00##", 1],
+        ["#111##1", 1],
+        ["11###11", 1],
+        ["1#10#00", 1],
+        ["10010#0", 1],
+        ["001100#", 1],
+        ["110#01#", 1],
+        ["01#111#", 1],
+        ["#1#0#11", 1],
+        ["##00111", 1],
+        ["##1#011", 1],
+        ["##1111#", 1],
+        ["#1##111", 1],
+        ["10#01#1", 1],
+        ["11#1##1", 1],
+        ["##111#1", 1],
+        ["#10110#", 1],
+        ["1#0101#", 1],
+        ["101#11#", 1],
+        ["11##0#1", 1],
+    ],
+    "COE_2": [
+        ["#00##00", 0],
+        ["00##000", 0],
+        ["010#1##", 0],
+        ["1001#0#", 0],
+        ["0#0###0", 0],
+        ["01#0#11", 0],
+        ["#1#001#", 0],
+        ["##0000#", 0],
+        ["0##0111", 0],
+        ["#1000##", 0],
+        ["100#00#", 0],
+        ["00#000#", 0],
+        ["00#011#", 0],
+        ["0#0011#", 0],
+        ["00101##", 0],
+        ["#1##010", 0],
+        ["###10#0", 0],
+        ["##01#00", 0],
+        ["00#1#10", 0],
+        ["0010#0#", 0],
+        ["00#01#0", 0],
+        ["#001##0", 0],
+        ["0100###", 0],
+        ["##0#0#0", 0],
+        ["001#11#", 0],
+        ["##0110#", 0],
+        ["00##110", 0],
+        ["00#0#00", 0],
+        ["#11#1#0", 1],
+        ["#01001#", 1],
+        ["##110#1", 1],
+        ["##1110#", 1],
+        ["1###111", 1],
+        ["#0##011", 1],
+        ["1#1#1##", 1],
+        ["1##011#", 1],
+        ["#1111##", 1],
+        ["11##11#", 1],
+        ["#111##1", 1],
+        ["10###11", 1],
+        ["#1#10#1", 1],
+        ["#110#0#", 1],
+        ["11#01##", 1],
+        ["#001#11", 1],
+        ["#11#10#", 1],
+        ["##11#01", 1],
+        ["1010###", 1],
+        ["101###1", 1],
+        ["1#10#0#", 1],
+        ["1##1#11", 1],
+        ["0##10#1", 1],
+        ["1##01#1", 1],
+        ["#000101", 1],
+        ["###1011", 1],
+        ["1#1##01", 1],
+        ["#11##01", 1],
+        ["1#11##1", 1],
+    ],
+    "MM401": [
+        ["11#0###", 0],
+        ["##1111#", 0],
+        ["11####1", 0],
+        ["1##01##", 0],
+        ["1###1#1", 0],
+        ["1#1###1", 0],
+        ["1#10###", 0],
+        ["1#1#11#", 0],
+        ["###1##1", 0],
+        ["0##0###", 1],
+        ["###1#00", 1],
+        ["###10#0", 1],
+        ["#00#0#0", 1],
+        ["0#0###0", 1],
+        ["0####00", 1],
+        ["##01##0", 1],
+        ["0###0#0", 1],
+        ["#0000##", 1],
+    ],
+}
+
+# annihilation and generation rules in automata
+annihilation_generation = {  # keeping annihilation and generation rules only
+    'GKL': [('###10#0', 0), ('1#10###', 1)],
+    'GP': [('###01#1', 1),
+    ('##10##1', 1),
+    ('0##1##0', 0),
+    ('0##10##', 0),
+    ('0#01###', 0),
+    ('1##0##1', 1)],
+    'GEP_1': [('###0#11', 1), ('##10##1', 1), ('0##10##', 0), ('00#1###', 0)],
+    'GEP_2': [('###1#00', 0), ('##01##0', 0), ('1##01##', 1), ('11#0###', 1)],
+    'Das': [('###01#1', 1),
+    ('###011#', 1),
+    ('##01#0#', 0),
+    ('##011#0', 0),
+    ('#001###', 0),
+    ('#1#01##', 1),
+    ('0#01###', 0),
+    ('1#001##', 1)],
+    'Davis': [('###1000', 0),
+    ('##0100#', 0),
+    ('##110#0', 0),
+    ('#0010#1', 0),
+    ('#1#10#0', 0),
+    ('#1#100#', 0),
+    ('#110#0#', 1),
+    ('#1101##', 1),
+    ('0#1011#', 1),
+    ('1#10#0#', 1),
+    ('1#100##', 1),
+    ('1110###', 1)],
+    'DMC': [('###0111', 1),
+    ('##101#1', 1),
+    ('#0#1100', 0),
+    ('#001#00', 0),
+    ('#0110#1', 0),
+    ('#01101#', 0),
+    ('#11011#', 1),
+    ('#111000', 0),
+    ('0##01#1', 1),
+    ('0##1100', 0),
+    ('0#01##0', 0),
+    ('0#01#1#', 0),
+    ('0#010##', 0),
+    ('00#10#1', 0),
+    ('00#101#', 0),
+    ('01#1#00', 0),
+    ('0101###', 0),
+    ('01101##', 1),
+    ('1#0011#', 1),
+    ('1#10#11', 1),
+    ('1010##1', 1),
+    ('1011#01', 0),
+    ('101110#', 0),
+    ('11#0#1#', 1),
+    ('11000#1', 1),
+    ('11001#0', 1),
+    ('11100#0', 1)],
+    'COE_1': [('##00111', 1),
+    ('##01001', 0),
+    ('##1001#', 1),
+    ('##11010', 0),
+    ('##11100', 0),
+    ('#0#1100', 0),
+    ('#0011#0', 0),
+    ('#00111#', 0),
+    ('#1#0#11', 1),
+    ('#1#1000', 0),
+    ('#10100#', 0),
+    ('#110100', 1),
+    ('#111#00', 0),
+    ('#1110#0', 0),
+    ('0##1010', 0),
+    ('0#010#0', 0),
+    ('0#0100#', 0),
+    ('0001##0', 0),
+    ('01#10#0', 0),
+    ('01010##', 0),
+    ('1##0111', 1),
+    ('1#01110', 0),
+    ('1#10#00', 1),
+    ('1#10#11', 1),
+    ('1#100##', 1),
+    ('1#11#00', 0),
+    ('1#110#0', 0),
+    ('10#01#1', 1),
+    ('10#1001', 0),
+    ('1010###', 1),
+    ('101100#', 0),
+    ('11#00##', 1)],
+    'COE_2': [('###10#0', 0),
+    ('##01#00', 0),
+    ('##0110#', 0),
+    ('#0#0011', 1),
+    ('#000101', 1),
+    ('#001##0', 0),
+    ('#01001#', 1),
+    ('#110#0#', 1),
+    ('#1101#0', 1),
+    ('0#01##0', 0),
+    ('00#1#10', 0),
+    ('001111#', 0),
+    ('01011##', 0),
+    ('1##01#1', 1),
+    ('1##011#', 1),
+    ('1#10#0#', 1),
+    ('1#101##', 1),
+    ('10#0#11', 1),
+    ('1001#0#', 0),
+    ('1010###', 1),
+    ('11#01##', 1)],
+    'MM401': [('###0#11', 1),
+    ('###01#1', 1),
+    ('##10##1', 1),
+    ('0##10##', 0),
+    ('0#01###', 0),
+    ('00#1###', 0)],
+    'MM802': [('###1010', 0),
+    ('##00101', 1),
+    ('##01#00', 0),
+    ('##010#0', 0),
+    ('##0110#', 0),
+    ('#000011', 1),
+    ('#001##0', 0),
+    ('#1#01#0', 1),
+    ('#1#010#', 1),
+    ('#1#10#0', 0),
+    ('#1001##', 1),
+    ('#101#0#', 0),
+    ('0#01##0', 0),
+    ('00#1#10', 0),
+    ('001111#', 0),
+    ('01011##', 0),
+    ('1##01#1', 1),
+    ('1##011#', 1),
+    ('1#01#0#', 0),
+    ('1#10#0#', 1),
+    ('1#101##', 1),
+    ('10#0#11', 1),
+    ('1010###', 1),
+    ('11#01##', 1)],
+    'F_WO_1': [('###0101', 1),
+    ('##01#00', 0),
+    ('##0110#', 0),
+    ('#0#1000', 0),
+    ('#000011', 1),
+    ('#001011', 0),
+    ('#0011#0', 0),
+    ('#1#01#0', 1),
+    ('#1#010#', 1),
+    ('#1#1001', 0),
+    ('#1001##', 1),
+    ('#101#0#', 0),
+    ('0#01011', 0),
+    ('0#011#0', 0),
+    ('0#10110', 1),
+    ('00#1110', 0),
+    ('00101#1', 1),
+    ('001011#', 1),
+    ('001111#', 0),
+    ('0101###', 0),
+    ('0110#0#', 1),
+    ('1#001#1', 1),
+    ('1#0011#', 1),
+    ('1#01#0#', 0),
+    ('1000#11', 1),
+    ('10010#1', 0),
+    ('11#01##', 1),
+    ('1110#1#', 1)],
+    'F_WO_2': [('###1010', 0),
+    ('##10#11', 1),
+    ('##1001#', 1),
+    ('#0#0110', 1),
+    ('#0#10#1', 0),
+    ('#0#101#', 0),
+    ('#010#1#', 1),
+    ('#0110##', 0),
+    ('#1#0111', 1),
+    ('#1100#1', 1),
+    ('#110100', 1),
+    ('#111100', 0),
+    ('0#10#1#', 1),
+    ('0#110#0', 0),
+    ('0#1100#', 0),
+    ('00#10##', 0),
+    ('0001#0#', 0),
+    ('01101#0', 1),
+    ('0111#00', 0),
+    ('1#01001', 0),
+    ('1#100#1', 1),
+    ('1#10100', 1),
+    ('1001#1#', 0),
+    ('1010###', 1),
+    ('11#0001', 1),
+    ('110000#', 1),
+    ('11010#0', 0),
+    ('110100#', 0)],
+    'F_WO_3': [('##00111', 1),
+    ('##10001', 1),
+    ('##110#0', 0),
+    ('##1100#', 0),
+    ('#0#10#0', 0),
+    ('#00011#', 1),
+    ('#001#10', 0),
+    ('#00111#', 0),
+    ('#010#01', 1),
+    ('#110#00', 1),
+    ('#1100##', 1),
+    ('0##1010', 0),
+    ('0001##0', 0),
+    ('00011##', 0),
+    ('01#101#', 0),
+    ('01110##', 0),
+    ('1##0111', 1),
+    ('1##1000', 0),
+    ('1#10#1#', 1),
+    ('1#100##', 1),
+    ('10#011#', 1),
+    ('1010##1', 1),
+    ('11#100#', 0),
+    ('1110##0', 1)],
+    'F_WO_4': [('##001#1', 1),
+    ('##0011#', 1),
+    ('##01110', 0),
+    ('##11000', 0),
+    ('#001#11', 0),
+    ('#0011##', 0),
+    ('#1#01#1', 1),
+    ('#101#10', 0),
+    ('#110#01', 1),
+    ('#11000#', 1),
+    ('#11100#', 0),
+    ('0##0111', 1),
+    ('0##1000', 0),
+    ('0#01#0#', 0),
+    ('0#011##', 0),
+    ('00#011#', 1),
+    ('0001##1', 0),
+    ('01#100#', 0),
+    ('0101##0', 0),
+    ('1##0101', 1),
+    ('10#010#', 1),
+    ('10001##', 1),
+    ('1110##1', 1),
+    ('11100##', 1)],
+    'F_WO_5': [('###1010', 0),
+    ('##10001', 1),
+    ('##110#0', 0),
+    ('##1100#', 0),
+    ('#0#10#0', 0),
+    ('#000011', 1),
+    ('#001#10', 0),
+    ('#00101#', 0),
+    ('#01011#', 1),
+    ('#100111', 1),
+    ('#1100##', 1),
+    ('00#1#10', 0),
+    ('0001##0', 0),
+    ('000110#', 0),
+    ('001111#', 0),
+    ('01110##', 0),
+    ('1##0111', 1),
+    ('1#10#1#', 1),
+    ('1#100##', 1),
+    ('10#0#11', 1),
+    ('10#011#', 1),
+    ('1010###', 1)],
+    'F_WO_10': [('##001#1', 1),
+    ('##0011#', 1),
+    ('##01110', 0),
+    ('##11000', 0),
+    ('#001#11', 0),
+    ('#0011##', 0),
+    ('#1#01#1', 1),
+    ('#1#100#', 0),
+    ('#101#10', 0),
+    ('#1010#0', 0),
+    ('#110#0#', 1),
+    ('0##0111', 1),
+    ('0##1000', 0),
+    ('0#01#0#', 0),
+    ('0#011##', 0),
+    ('00#011#', 1),
+    ('0001##1', 0),
+    ('0101##0', 0),
+    ('1##0101', 1),
+    ('1#1010#', 1),
+    ('10#010#', 1),
+    ('10001##', 1),
+    ('1110##1', 1),
+    ('11100##', 1)],
+    'F_WO_50': [('##11010', 0),
+    ('##11100', 0),
+    ('#0#1010', 0),
+    ('#0010#0', 0),
+    ('#010001', 1),
+    ('#1#1100', 0),
+    ('#110011', 1),
+    ('#110100', 1),
+    ('#111#00', 0),
+    ('#1110#0', 0),
+    ('0#11#00', 0),
+    ('0#110#0', 0),
+    ('00#10#0', 0),
+    ('001100#', 0),
+    ('011101#', 0),
+    ('1#01000', 0),
+    ('1#10#11', 1),
+    ('1#100#1', 1),
+    ('1#1000#', 1),
+    ('1#1011#', 1),
+    ('1010#1#', 1),
+    ('10100##', 1),
+    ('11#0#00', 1),
+    ('11#00#1', 1),
+    ('11#000#', 1),
+    ('11#1#00', 0),
+    ('1100#0#', 1),
+    ('11000##', 1),
+    ('110100#', 0),
+    ('11101#0', 1)],
+    'F_WO_100': [('###1010', 0),
+    ('##10#11', 1),
+    ('#0#0110', 1),
+    ('#0#101#', 0),
+    ('#0010#1', 0),
+    ('#010#1#', 1),
+    ('#1#0111', 1),
+    ('#1#1100', 0),
+    ('#1100#1', 1),
+    ('0#01100', 0),
+    ('0#1011#', 1),
+    ('0#110#0', 0),
+    ('0#1100#', 0),
+    ('00#10##', 0),
+    ('0001#0#', 0),
+    ('0111#00', 0),
+    ('1#100#1', 1),
+    ('1001#1#', 0),
+    ('1010###', 1),
+    ('11#0001', 1),
+    ('1100#0#', 1),
+    ('11001#1', 1)],
+    'F_WO_500': [('##00101', 1),
+    ('##11000', 0),
+    ('#0#1000', 0),
+    ('#001#00', 0),
+    ('#001#11', 0),
+    ('#0011#1', 0),
+    ('#00110#', 0),
+    ('#1#0101', 1),
+    ('#100#11', 1),
+    ('#1001#1', 1),
+    ('#10011#', 1),
+    ('#101010', 0),
+    ('#110#01', 1),
+    ('#11000#', 1),
+    ('#11100#', 0),
+    ('0##1000', 0),
+    ('0#001#1', 1),
+    ('0#0011#', 1),
+    ('0#01#00', 0),
+    ('0#011#1', 0),
+    ('0#0110#', 0),
+    ('0#10001', 1),
+    ('00#011#', 1),
+    ('00#1#00', 0),
+    ('00#110#', 0),
+    ('01#100#', 0),
+    ('0101##0', 0),
+    ('0101#0#', 0),
+    ('01011##', 0),
+    ('01110#1', 0),
+    ('1##0101', 1),
+    ('101010#', 1),
+    ('11#0#11', 1),
+    ('11#01#1', 1),
+    ('11#011#', 1),
+    ('1110##1', 1),
+    ('1110#1#', 1),
+    ('11100##', 1)],
+    'F_WO_1000': [('##001#1', 1),
+    ('##0011#', 1),
+    ('#0#1000', 0),
+    ('#001#00', 0),
+    ('#001#11', 0),
+    ('#0011##', 0),
+    ('#1#0101', 1),
+    ('#101010', 0),
+    ('#110#01', 1),
+    ('#111100', 0),
+    ('0##1000', 0),
+    ('0#01#00', 0),
+    ('0#011##', 0),
+    ('0#10001', 1),
+    ('00#011#', 1),
+    ('01#1#00', 0),
+    ('01#100#', 0),
+    ('0101##0', 0),
+    ('0101#0#', 0),
+    ('01110#1', 0),
+    ('1##0101', 1),
+    ('101010#', 1),
+    ('11#0#01', 1),
+    ('11#01#1', 1),
+    ('11#011#', 1),
+    ('110000#', 1),
+    ('1110##1', 1),
+    ('1110#1#', 1)],
+    'F_WO_3000': [('##00#11', 1),
+    ('##01000', 0),
+    ('##10110', 1),
+    ('#0#1001', 0),
+    ('#001#0#', 0),
+    ('#010001', 1),
+    ('#0110#1', 0),
+    ('#1#011#', 1),
+    ('#1#10#0', 0),
+    ('#1001#1', 1),
+    ('0##0011', 1),
+    ('0#01#00', 0),
+    ('0#0110#', 0),
+    ('0#10#10', 1),
+    ('0#1001#', 1),
+    ('0#11011', 0),
+    ('00#1#01', 0),
+    ('00#11##', 0),
+    ('00100#1', 1),
+    ('0011##1', 0),
+    ('01#0#11', 1),
+    ('0110#1#', 1),
+    ('011101#', 0),
+    ('1#010#0', 0),
+    ('1#10#0#', 1),
+    ('1#101#0', 1),
+    ('10#10#1', 0),
+    ('10010##', 0),
+    ('11#01#1', 1),
+    ('11101##', 1)],
+    'F_WO_7000': [('##11010', 0),
+    ('#0#1010', 0),
+    ('#000011', 1),
+    ('#010101', 1),
+    ('#0110#0', 0),
+    ('#01100#', 0),
+    ('#1#0111', 1),
+    ('#110#11', 1),
+    ('#1100#1', 1),
+    ('#110100', 1),
+    ('#111100', 0),
+    ('0##1010', 0),
+    ('0#110#0', 0),
+    ('0#1100#', 0),
+    ('00#10#0', 0),
+    ('00#100#', 0),
+    ('0001#0#', 0),
+    ('010101#', 0),
+    ('0111#00', 0),
+    ('1#01110', 0),
+    ('1#10#11', 1),
+    ('1#100#1', 1),
+    ('10#0011', 1),
+    ('10#0110', 1),
+    ('10001#0', 1),
+    ('1001#10', 0),
+    ('100111#', 0),
+    ('1010##1', 1),
+    ('1010#1#', 1),
+    ('10100##', 1),
+    ('11#0001', 1),
+    ('1100#01', 1),
+    ('110000#', 1),
+    ('11001#1', 1),
+    ('110100#', 0)]
+    }
+# maintenance rules in automata, from the function get_maintenance_rules in automata/automata_rules.py
+maintenance = {
+    "GKL": [
+        ["0###0#0", 0],
+        ["##00###", 0],
+        ["##0#0#0", 0],
+        ["0##0###", 0],
+        ["1#1#1##", 1],
+        ["1#1###1", 1],
+        ["###11##", 1],
+        ["###1##1", 1],
+    ],
+    "GP": [
+        ["0#0#0##", 0],
+        ["###0##0", 0],
+        ["##1#1#1", 1],
+        ["1##1###", 1],
+        ["0##0##0", 0],
+        ["1##1##1", 1],
+    ],
+    "GEP_1": [
+        ["0###0#0", 0],
+        ["00####0", 0],
+        ["0#0#00#", 0],
+        ["##00#0#", 0],
+        ["###0##0", 0],
+        ["000##0#", 0],
+        ["1####11", 1],
+        ["1##1###", 1],
+        ["#1#11##", 1],
+        ["1#1###1", 1],
+        ["#11#1#1", 1],
+        ["#1##111", 1],
+    ],
+    "GEP_2": [
+        ["#0##000", 0],
+        ["0####00", 0],
+        ["#00#0#0", 0],
+        ["#0#00##", 0],
+        ["0##0###", 0],
+        ["0#0###0", 0],
+        ["1#1#11#", 1],
+        ["##11#1#", 1],
+        ["11####1", 1],
+        ["111##1#", 1],
+        ["###1##1", 1],
+        ["1###1#1", 1],
+    ],
+    "Das": [
+        ["###00##", 0],
+        ["0#0#0##", 0],
+        ["#010#00", 0],
+        ["00#0#00", 0],
+        ["#00#0##", 0],
+        ["000##00", 0],
+        ["##0#00#", 0],
+        ["##1#1#1", 1],
+        ["##1#11#", 1],
+        ["11##111", 1],
+        ["##11###", 1],
+        ["11#1#11", 1],
+        ["#11#1##", 1],
+        ["11#101#", 1],
+    ],
+    "Davis": [
+        ["#10#0#0", 0],
+        ["0#1#010", 0],
+        ["10#011#", 0],
+        ["00##000", 0],
+        ["0##001#", 0],
+        ["001#0#0", 0],
+        ["##00###", 0],
+        ["00#00##", 0],
+        ["00#0#0#", 0],
+        ["01##010", 0],
+        ["111##11", 1],
+        ["#1#1#11", 1],
+        ["101##01", 1],
+        ["#011##1", 1],
+        ["1#1#011", 1],
+        ["101#0#1", 1],
+        ["#001#10", 1],
+        ["##11#11", 1],
+        ["###11##", 1],
+        ["1#1#10#", 1],
+        ["##0000#", 0],
+        ["#0000#1", 0],
+        ["0#1111#", 1],
+        ["#1111##", 1],
+    ],
+    "ABK": [
+        ["0#0#0##", 0],
+        ["###0##0", 0],
+        ["##1#1#1", 1],
+        ["1##1###", 1],
+        ["0##0##0", 0],
+        ["1##1##1", 1],
+    ],
+    "DMC": [
+        ["#0000##", 0],
+        ["01##000", 0],
+        ["1#10100", 0],
+        ["#010##0", 0],
+        ["##00000", 0],
+        ["0##00##", 0],
+        ["#110001", 0],
+        ["#0#00#0", 0],
+        ["#01#010", 0],
+        ["00#0##0", 0],
+        ["1#00101", 0],
+        ["#0#0#00", 0],
+        ["1000#0#", 0],
+        ["#011000", 1],
+        ["1#01#1#", 1],
+        ["#11#1#1", 1],
+        ["1##111#", 1],
+        ["0#1#1#1", 1],
+        ["00##101", 1],
+        ["#111#1#", 1],
+        ["1###111", 1],
+        ["11#11##", 1],
+        ["##1111#", 1],
+        ["11#1##1", 1],
+        ["#001101", 1],
+        ["##1#111", 1],
+        ["#111##1", 1],
+        ["1#01##1", 1],
+        ["1101###", 1],
+        ["0#00##0", 0],
+        ["#000#00", 0],
+        ["0#000##", 0],
+        ["00#001#", 0],
+        ["00#00#1", 0],
+        ["#0#0100", 0],
+        ["1#0111#", 1],
+        ["11011#0", 1],
+        ["11010#1", 1],
+        ["#11111#", 1],
+        ["11#1#1#", 1],
+    ],
+    "COE_1": [
+        ["00##100", 0],
+        ["0##0#01", 0],
+        ["#10010#", 0],
+        ["0#00##0", 0],
+        ["00101##", 0],
+        ["00#01#0", 0],
+        ["#000##0", 0],
+        ["0##0110", 0],
+        ["#0000##", 0],
+        ["01##000", 0],
+        ["0#00#0#", 0],
+        ["##001#0", 0],
+        ["0##000#", 0],
+        ["00#0#0#", 0],
+        ["#1#0101", 0],
+        ["#1#0110", 0],
+        ["0#11##1", 1],
+        ["#10110#", 1],
+        ["#11##11", 1],
+        ["11##0#1", 1],
+        ["#1##111", 1],
+        ["#1#11#1", 1],
+        ["##1111#", 1],
+        ["10010#0", 1],
+        ["1##1011", 1],
+        ["001100#", 1],
+        ["##11#11", 1],
+        ["110#01#", 1],
+        ["01011##", 1],
+        ["#0#1011", 1],
+        ["11###11", 1],
+        ["101#11#", 1],
+        ["101#1#1", 1],
+        ["01#111#", 1],
+        ["11#1##1", 1],
+        ["10##101", 1],
+        ["##111#1", 1],
+        ["#111##1", 1],
+        ["##1#011", 1],
+        ["1#0101#", 1],
+        ["###1101", 1],
+        ["1#00110", 0],
+        ["0#000#0", 0],
+        ["0000##0", 0],
+        ["#000001", 0],
+        ["#0001#0", 0],
+        ["0#0000#", 0],
+        ["1#11#11", 1],
+    ],
+    "COE_2": [
+        ["#1000##", 0],
+        ["00##000", 0],
+        ["#1#001#", 0],
+        ["00#000#", 0],
+        ["0010#0#", 0],
+        ["0100###", 0],
+        ["##0000#", 0],
+        ["00#0#00", 0],
+        ["#1##010", 0],
+        ["0##0111", 0],
+        ["00101##", 0],
+        ["##0#0#0", 0],
+        ["00#011#", 0],
+        ["0#0011#", 0],
+        ["100#00#", 0],
+        ["00#01#0", 0],
+        ["00##110", 0],
+        ["#00##00", 0],
+        ["01#0#11", 0],
+        ["##1110#", 1],
+        ["1#1##01", 1],
+        ["##11#01", 1],
+        ["1#11##1", 1],
+        ["###1011", 1],
+        ["#1#10#1", 1],
+        ["1##1#11", 1],
+        ["#11##01", 1],
+        ["1###111", 1],
+        ["101###1", 1],
+        ["#1111##", 1],
+        ["#001#11", 1],
+        ["11##11#", 1],
+        ["##110#1", 1],
+        ["#111##1", 1],
+        ["0##10#1", 1],
+        ["#11#10#", 1],
+        ["0#00##0", 0],
+        ["001011#", 0],
+        ["01001##", 0],
+        ["#1111#0", 1],
+        ["#0#1011", 1],
+        ["1#111##", 1],
+        ["10#1#11", 1],
+    ],
+    "MM401": [
+        ["1#1#11#", 0],
+        ["1#10###", 0],
+        ["11####1", 0],
+        ["11#0###", 0],
+        ["1#1###1", 0],
+        ["1##01##", 0],
+        ["1###1#1", 0],
+        ["0###0#0", 1],
+        ["###1#00", 1],
+        ["###10#0", 1],
+        ["0####00", 1],
+        ["#00#0#0", 1],
+        ["0#0###0", 1],
+        ["##01##0", 1],
+    ],
+}
diff --git a/automata/ks_for_anni_gen.ipynb b/automata/ks_for_anni_gen.ipynb
new file mode 100644
index 0000000..922c135
--- /dev/null
+++ b/automata/ks_for_anni_gen.ipynb
@@ -0,0 +1,218 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from automata_rules import automata_output_list\n",
+    "from cana.boolean_node import BooleanNode\n",
+    "from cana.drawing.schema_vis import plot_schemata\n",
+    "# from schema_search_tools import annihilation_generation_rules\n",
+    "from cana.utils import fill_out_lut"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Input symmetry: 1.7083333333333335\n",
+      "Input symmetry mean: 1.7083333333333337\n"
+     ]
+    }
+   ],
+   "source": [
+    "rule='GP'\n",
+    "node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "node._check_compute_canalization_variables(ts_coverage=True)\n",
+    "anni_gen = node.get_annihilation_generation_rules()\n",
+    "print(f\"Input symmetry: {node.input_symmetry()}\")\n",
+    "print(f\"Input symmetry mean: {node.input_symmetry_mean()}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# code: input symmetry mean for annihilation and generation rules\n",
+    "refactored into the BooleanNode class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Summand: 98.66666666666666\n",
+      "Total coverage in LUT: 56\n",
+      "Input symmetry mean anni_gen: 1.7619047619047616\n",
+      "     Input  Output\n",
+      "0  ###0##0       0\n",
+      "1  0##10##       0\n",
+      "2  0#01###       0\n",
+      "3  0#0#0##       0\n",
+      "4  0#####0       0\n",
+      "5  1##1###       1\n",
+      "6  1#####1       1\n",
+      "7  ##1#1#1       1\n",
+      "8  ###01#1       1\n",
+      "9  ##10##1       1\n",
+      "[['0##1##0', 0], ['0##10##', 0], ['0#01###', 0], ['###01#1', 1], ['1##0##1', 1], ['##10##1', 1]]\n",
+      "     Input  Output\n",
+      "0  ######0       0\n",
+      "1  ###1###       0\n",
+      "2  0#0#0##       0\n",
+      "3  ###01#1       1\n",
+      "4  1##0##1       1\n",
+      "5  ##10##1       1\n"
+     ]
+    }
+   ],
+   "source": [
+    "rule='GP'\n",
+    "node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "def input_symmetry_mean_anni_gen(node):\n",
+    "    \"\"\"\n",
+    "    Gets creations/annihilations in the LUT, which includes the creation/annihilation part of the soft creations/annihilations in the ts-schemata.\n",
+    "    \"\"\"\n",
+    "    node._check_compute_canalization_variables(ts_coverage=True) # computing the ts_coverage if not already computed\n",
+    "    \n",
+    "    anni_gen = node.get_annihilation_generation_rules() # getting the annihilation generation rules for the node\n",
+    "    anni_gen_coverage = [] # dict to store the rules covered in anni_gen\n",
+    "    for key, value in fill_out_lut(anni_gen): # expanding anni_gen rules to get the rules covered in LUT\n",
+    "        if value != '?':\n",
+    "            anni_gen_coverage.append(key)\n",
+    "\n",
+    "    summand = 0 # summand for the mean of the number of input values that are not # if the rule is covered in two-symbol\n",
+    "    for rule in anni_gen_coverage: # only iterating over the rules that are covered in anni_gen\n",
+    "        inner = 0\n",
+    "        for ts in node._ts_coverage[rule]:\n",
+    "            inner += sum(\n",
+    "                        len(i) for i in ts[1]\n",
+    "                    )\n",
+    "        summand += inner / len(node._ts_coverage[rule])\n",
+    "    print(f\"Summand: {summand}\")\n",
+    "    print(f\"Total coverage in LUT: {len(anni_gen_coverage)}\")\n",
+    "\n",
+    "    return summand/len(anni_gen_coverage) # returning the mean of the number of input values that are not # for all anni_gen rules\n",
+    "\n",
+    "print(f\"Input symmetry mean anni_gen: {input_symmetry_mean_anni_gen(node)}\")\n",
+    "print(node.schemata_look_up_table())\n",
+    "print(node.get_annihilation_generation_rules())\n",
+    "lut = node.look_up_table()\n",
+    "generation_outputs = (  # generates an LUT which is NOT RULE & (X_4), where X_4 is the middle input. the result is 1 for all the rules that generate and 0 for all the others.\n",
+    "        ((lut[\"Out:\"] == \"1\") & (lut[\"In:\"].str[3] == \"0\")).apply(lambda x: \"1\" if x else \"0\").tolist()\n",
+    "    )\n",
+    "generation = BooleanNode.from_output_list(generation_outputs)\n",
+    "print(generation.schemata_look_up_table())\n",
+    "# node._ts_coverage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rule: GKL\n",
+      "Input symmetry: 1.6875\n",
+      "Input symmetry mean: 1.6875\n",
+      "Input symmetry mean anni_gen: 0.75\n",
+      "\n",
+      "Rule: GP\n",
+      "Input symmetry: 1.7083333333333335\n",
+      "Input symmetry mean: 1.7083333333333337\n",
+      "Input symmetry mean anni_gen: 1.7619047619047616\n",
+      "\n",
+      "Rule: GEP_1\n",
+      "Input symmetry: 0.984375\n",
+      "Input symmetry mean: 0.984375\n",
+      "Input symmetry mean anni_gen: 2.0\n",
+      "\n",
+      "Rule: GEP_2\n",
+      "Input symmetry: 0.984375\n",
+      "Input symmetry mean: 0.984375\n",
+      "Input symmetry mean anni_gen: 2.0\n",
+      "\n",
+      "Rule: Das\n",
+      "Input symmetry: 1.5338541666666667\n",
+      "Input symmetry mean: 1.5338541666666663\n",
+      "Input symmetry mean anni_gen: 2.528735632183908\n",
+      "\n",
+      "Rule: Davis\n",
+      "Input symmetry: 0.7770833333333333\n",
+      "Input symmetry mean: 0.7770833333333335\n",
+      "Input symmetry mean anni_gen: 1.3590909090909093\n",
+      "\n",
+      "Rule: ABK\n",
+      "Input symmetry: 1.7083333333333335\n",
+      "Input symmetry mean: 1.7083333333333337\n",
+      "Input symmetry mean anni_gen: 1.7619047619047616\n",
+      "\n",
+      "Rule: DMC\n",
+      "Input symmetry: 1.7911427331349206\n",
+      "Input symmetry mean: 1.7911427331349203\n",
+      "Input symmetry mean anni_gen: 1.541812865497076\n",
+      "\n",
+      "Rule: COE_1\n",
+      "Input symmetry: 1.9546533978174603\n",
+      "Input symmetry mean: 1.9546533978174607\n",
+      "Input symmetry mean anni_gen: 1.8775451559934317\n",
+      "\n",
+      "Rule: COE_2\n",
+      "Input symmetry: 1.4994915674603173\n",
+      "Input symmetry mean: 1.499491567460318\n",
+      "Input symmetry mean anni_gen: 1.311943164362519\n",
+      "\n",
+      "Rule: MM401\n",
+      "Input symmetry: 1.7760416666666665\n",
+      "Input symmetry mean: 1.7760416666666663\n",
+      "Input symmetry mean anni_gen: 0.8703703703703703\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for rule in automata_output_list:\n",
+    "    node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "    print(f\"Rule: {rule}\\nInput symmetry: {node.input_symmetry()}\")\n",
+    "    print(f\"Input symmetry mean: {node.input_symmetry_mean()}\")\n",
+    "    print(f\"Input symmetry mean anni_gen: {node.input_symmetry_mean_anni_gen()}\\n\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/automata/ks_ke_bias_for_anni_gen.ipynb b/automata/ks_ke_bias_for_anni_gen.ipynb
new file mode 100644
index 0000000..fa8aaf8
--- /dev/null
+++ b/automata/ks_ke_bias_for_anni_gen.ipynb
@@ -0,0 +1,344 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from automata_rules import automata_output_list\n",
+    "from cana.boolean_node import BooleanNode\n",
+    "from cana.drawing.schema_vis import plot_schemata, plot_anni_gen_schemata\n",
+    "# from schema_search_tools import annihilation_generation_rules\n",
+    "from cana.utils import fill_out_lut\n",
+    "import schematodes as sc\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.collections import PatchCollection\n",
+    "from matplotlib.patches import Circle, Rectangle, RegularPolygon\n",
+    "from matplotlib.text import Text\n",
+    "import numpy as np\n",
+    "import copy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Input symmetry: 1.7083333333333335\n",
+      "Input symmetry mean: 1.7083333333333337\n"
+     ]
+    }
+   ],
+   "source": [
+    "rule='GP'\n",
+    "node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "node._check_compute_canalization_variables(ts_coverage=True)\n",
+    "anni_gen = node.get_annihilation_generation_rules()\n",
+    "print(f\"Input symmetry: {node.input_symmetry()}\")\n",
+    "print(f\"Input symmetry mean: {node.input_symmetry_mean()}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# code: input symmetry mean for annihilation and generation rules\n",
+    "refactored into the BooleanNode class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Summand: 98.66666666666666\n",
+      "Total coverage in LUT: 56\n",
+      "Input symmetry mean anni_gen: 1.7619047619047616\n",
+      "     Input  Output\n",
+      "0  0##10##       0\n",
+      "1  0#0#0##       0\n",
+      "2  0#####0       0\n",
+      "3  0#01###       0\n",
+      "4  ###0##0       0\n",
+      "5  ##1#1#1       1\n",
+      "6  1#####1       1\n",
+      "7  1##1###       1\n",
+      "8  ###01#1       1\n",
+      "9  ##10##1       1\n",
+      "[['0##1##0', 0], ['0##10##', 0], ['0#01###', 0], ['###01#1', 1], ['1##0##1', 1], ['##10##1', 1]]\n",
+      "     Input  Output\n",
+      "0  ######0       0\n",
+      "1  ###1###       0\n",
+      "2  0#0#0##       0\n",
+      "3  ###01#1       1\n",
+      "4  1##0##1       1\n",
+      "5  ##10##1       1\n"
+     ]
+    }
+   ],
+   "source": [
+    "rule='GP'\n",
+    "node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "def input_symmetry_mean_anni_gen(node):\n",
+    "    \"\"\"\n",
+    "    Gets creations/annihilations in the LUT, which includes the creation/annihilation part of the soft creations/annihilations in the ts-schemata.\n",
+    "    \"\"\"\n",
+    "    node._check_compute_canalization_variables(ts_coverage=True) # computing the ts_coverage if not already computed\n",
+    "    \n",
+    "    anni_gen = node.get_annihilation_generation_rules() # getting the annihilation generation rules for the node\n",
+    "    anni_gen_coverage = [] # dict to store the rules covered in anni_gen\n",
+    "    for key, value in fill_out_lut(anni_gen): # expanding anni_gen rules to get the rules covered in LUT\n",
+    "        if value != '?':\n",
+    "            anni_gen_coverage.append(key)\n",
+    "\n",
+    "    summand = 0 # summand for the mean of the number of input values that are not # if the rule is covered in two-symbol\n",
+    "    for rule in anni_gen_coverage: # only iterating over the rules that are covered in anni_gen\n",
+    "        inner = 0\n",
+    "        for ts in node._ts_coverage[rule]:\n",
+    "            inner += sum(\n",
+    "                        len(i) for i in ts[1]\n",
+    "                    )\n",
+    "        summand += inner / len(node._ts_coverage[rule])\n",
+    "    print(f\"Summand: {summand}\")\n",
+    "    print(f\"Total coverage in LUT: {len(anni_gen_coverage)}\")\n",
+    "\n",
+    "    return summand/len(anni_gen_coverage) # returning the mean of the number of input values that are not # for all anni_gen rules\n",
+    "\n",
+    "print(f\"Input symmetry mean anni_gen: {input_symmetry_mean_anni_gen(node)}\")\n",
+    "print(node.schemata_look_up_table())\n",
+    "print(node.get_annihilation_generation_rules())\n",
+    "lut = node.look_up_table()\n",
+    "generation_outputs = (  # generates an LUT which is NOT RULE & (X_4), where X_4 is the middle input. the result is 1 for all the rules that generate and 0 for all the others.\n",
+    "        ((lut[\"Out:\"] == \"1\") & (lut[\"In:\"].str[3] == \"0\")).apply(lambda x: \"1\" if x else \"0\").tolist()\n",
+    "    )\n",
+    "generation = BooleanNode.from_output_list(generation_outputs)\n",
+    "print(generation.schemata_look_up_table())\n",
+    "# node._ts_coverage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for rule in automata_output_list:\n",
+    "#     node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "    # print(f\"Rule: {rule}\\nInput symmetry: {node.input_symmetry()}\")\n",
+    "    # print(f\"Input symmetry mean: {node.input_symmetry_mean()}\")\n",
+    "    # print(f\"Input symmetry mean anni_gen: {node.input_symmetry_mean_anni_gen()}\\n\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# $K_e, K_r$ for anni_gen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rule: GKL\n",
+      "Anni_Gen K_r: 4.0\n",
+      "K_r: 4.65625\n",
+      "\n",
+      "Rule: GP\n",
+      "Anni_Gen K_r: 4.0\n",
+      "K_r: 4.619791666666666\n",
+      "\n",
+      "Rule: GEP_1\n",
+      "Anni_Gen K_r: 4.0\n",
+      "K_r: 4.268229166666666\n",
+      "\n",
+      "Rule: GEP_2\n",
+      "Anni_Gen K_r: 4.0\n",
+      "K_r: 4.268229166666666\n",
+      "\n",
+      "Rule: Das\n",
+      "Anni_Gen K_r: 3.8706896551724137\n",
+      "K_r: 4.138504464285714\n",
+      "\n",
+      "Rule: Davis\n",
+      "Anni_Gen K_r: 2.8636363636363638\n",
+      "K_r: 3.64296875\n",
+      "\n",
+      "Rule: DMC\n",
+      "Anni_Gen K_r: 2.3236842105263156\n",
+      "K_r: 2.813368337391775\n",
+      "\n",
+      "Rule: COE_1\n",
+      "Anni_Gen K_r: 2.2649717514124292\n",
+      "K_r: 2.4683283730158734\n",
+      "\n",
+      "Rule: COE_2\n",
+      "Anni_Gen K_r: 2.8631720430107523\n",
+      "K_r: 2.96691158234127\n",
+      "\n",
+      "Rule: MM401\n",
+      "Anni_Gen K_r: 4.0\n",
+      "K_r: 4.244122023809524\n",
+      "\n",
+      "Rule: MM802\n",
+      "Anni_Gen K_r: 2.7881720430107526\n",
+      "K_r: 2.9411086309523813\n",
+      "\n",
+      "Rule: F_WO_1\n",
+      "Anni_Gen K_r: 2.335057471264368\n",
+      "K_r: 2.5259796626984126\n",
+      "\n",
+      "Rule: F_WO_2\n",
+      "Anni_Gen K_r: 2.335057471264368\n",
+      "K_r: 2.525979662698413\n",
+      "\n",
+      "Rule: F_WO_3\n",
+      "Anni_Gen K_r: 2.391975308641975\n",
+      "K_r: 2.678050595238095\n",
+      "\n",
+      "Rule: F_WO_4\n",
+      "Anni_Gen K_r: 2.3919753086419755\n",
+      "K_r: 2.678050595238095\n",
+      "\n",
+      "Rule: F_WO_5\n",
+      "Anni_Gen K_r: 2.441358024691358\n",
+      "K_r: 2.7845982142857144\n",
+      "\n",
+      "Rule: F_WO_10\n",
+      "Anni_Gen K_r: 2.536781609195402\n",
+      "K_r: 2.77734375\n",
+      "\n",
+      "Rule: F_WO_50\n",
+      "Anni_Gen K_r: 1.7777777777777775\n",
+      "K_r: 2.7099330357142857\n",
+      "\n",
+      "Rule: F_WO_100\n",
+      "Anni_Gen K_r: 2.361111111111111\n",
+      "K_r: 2.6383928571428568\n",
+      "\n",
+      "Rule: F_WO_500\n",
+      "Anni_Gen K_r: 1.8950617283950617\n",
+      "K_r: 2.3839409722222222\n",
+      "\n",
+      "Rule: F_WO_1000\n",
+      "Anni_Gen K_r: 2.14320987654321\n",
+      "K_r: 2.533017113095238\n",
+      "\n",
+      "Rule: F_WO_3000\n",
+      "Anni_Gen K_r: 2.4139784946236564\n",
+      "K_r: 2.623369295634921\n",
+      "\n",
+      "Rule: F_WO_7000\n",
+      "Anni_Gen K_r: 1.5733333333333335\n",
+      "K_r: 2.161080109126984\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "for rule in automata_output_list:\n",
+    "    node = BooleanNode.from_output_list(automata_output_list[rule])\n",
+    "    rule_kr = node.input_redundancy(norm = False)\n",
+    "    k_r = node.input_redundancy_anni_gen()\n",
+    "    # rule_ke = node.effective_connectivity(norm=False)\n",
+    "    # ke = node.effective_connectivity_anni_gen()\n",
+    "    # print(f\"Rule: {rule}\\nAnni_Gen K_r: {k_r}\\nK_r: {rule_kr}\\nAnni_Gen K_e: {ke}\\nK_e: {rule_ke}\\n\") \n",
+    "    print(f\"Rule: {rule}\\nAnni_Gen K_r: {k_r}\\nK_r: {rule_kr}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# two symbol for annihilation and generation rules "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO: [SRI] CREATE an annihilation and generation plot like plot schemata.\n",
+    "# TODO: [SRI] FIND TWO SYMBOLS COMPRESSED FORM FOR ANNIHILATION AND GENERATION RULES"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Annigen_symetry : 1.7619047619047616\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1147x854 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1147x590 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "name = 'GP'\n",
+    "node = BooleanNode.from_output_list(automata_output_list[name])\n",
+    "annigen_symmetry = node.input_symmetry_mean_anni_gen()\n",
+    "print(f\"Annigen_symetry : {annigen_symmetry}\")\n",
+    "plot_schemata(node)\n",
+    "plot_anni_gen_schemata(node)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/automata/schema_search_tools.py b/automata/schema_search_tools.py
new file mode 100644
index 0000000..687fec7
--- /dev/null
+++ b/automata/schema_search_tools.py
@@ -0,0 +1,675 @@
+import random
+from typing import Generator
+from matplotlib import pyplot as plt
+from cana.boolean_node import BooleanNode
+import pandas as pd
+from automata.automata_rules import automata_output_list
+
+# list of useful functions for the schema search
+
+def annihilation_generation_rules(output_list: list, split: bool = False) -> list:
+    """
+    This function takes in a list of outputs from an automata and returns a dataframe with the rules that are annihilation and generation rules.
+
+    Args:
+    output_list: list of outputs from an automata
+
+    Returns:
+    annihilation_generation_rules: dataframe with the rules that are annihilation and generation rules.
+
+    Method:
+    Using BooleanNode from CANA, it creates a look-up-table from a list of outputs.
+    It generates new lookup tables for annihilation(using logic [RULE & (NOT X_4)]) and generation(using logic [NOT RULE & (X_4)]).
+    The rows that output 1 in the new schematas are the annihilations and generations.
+    We combine the two dataframes to get the final dataframe. We reassign the annihilation output to 0.
+
+    Example:
+    output_list = ['0', '1', '0', '1', '1', '0', '1', '0']
+    annihilation_generation_rules(output_list)
+
+    """
+
+    node = BooleanNode.from_output_list(
+        output_list
+    )  # creating a node from the output list
+    lut = node.look_up_table()
+
+    annihilation_outputs_lut = (  # generates an LUT which is RULE & (NOT X_4), where X_4 is the middle input. the result is 1 for all the rules that annihilate and 0 for all the others.
+        ((lut["Out:"] == "0") & (lut["In:"].str[3] == "1"))
+        .apply(lambda x: "1" if x else "0")
+        .tolist()
+    )
+    annihilation = BooleanNode.from_output_list(annihilation_outputs_lut)
+    temp = annihilation.schemata_look_up_table()  # generating a new schemata from the new LUT to identify the rules that are annihilation
+    annihilation_rules = temp[
+        temp["Output"] == 1
+    ]  # filtering the rules that are annihilation
+    annihilation_rules.loc[:, "Output"] = (
+        0  # reassigning the output to 0 since it is an annihilation rule
+    )
+
+    generation_outputs = (  # generates an LUT which is NOT RULE & (X_4), where X_4 is the middle input. the result is 1 for all the rules that generate and 0 for all the others.
+        ((lut["Out:"] == "1") & (lut["In:"].str[3] == "0"))
+        .apply(lambda x: "1" if x else "0")
+        .tolist()
+    )
+    generation = BooleanNode.from_output_list(generation_outputs)
+
+    temp = generation.schemata_look_up_table()  # generating a new schemata from the new LUT to identify the rules that are generation
+    generation_rules = temp[
+        temp["Output"] == 1
+    ]  # filtering the rules that are generation
+    generation_rules.loc[:, "Output"] = (
+        1  # reassigning the output to 1 since it is a generation rule
+    )
+    if split:
+        return annihilation_rules.values.tolist(), generation_rules.values.tolist()
+    # combining the two dataframes to get the final dataframe
+    annihilation_generation_rules = pd.concat([annihilation_rules, generation_rules])
+
+    # converting it into a list
+    annihilation_generation_rules = annihilation_generation_rules.values.tolist()
+
+    return annihilation_generation_rules
+
+def maintenance_rules(output_list: list) -> list:
+    """
+    This function takes in a list of outputs from an automata and returns a list of maintenance rules.
+
+    Args:
+    output_list: list of outputs from an automata
+
+    Returns:
+    maintenance_rules: list of maintenance rules
+
+    Method:
+    Using BooleanNode from CANA, it creates a look-up-table from a list of outputs.
+    Using the annihilation_generation_rules function, it generates a list of annihilation and generation rules.
+    It looks for the corresponding rule in the schemata and removes it.
+    For cases where the annihilation or generation rule is partially in the schemata, it splits the corresponding rule and retrieves the maintenance part.
+
+
+    Example:
+    output_list = ['0', '1', '0', '1', '1', '0', '1', '0']
+    maintenance_rules(output_list)
+
+    """
+    schemata = BooleanNode.from_output_list(output_list).schemata_look_up_table()
+    schemata = schemata.values.tolist()
+    anni_gen_rules = annihilation_generation_rules(output_list)
+
+    for rule in anni_gen_rules:
+        if (
+            rule in schemata
+        ):  # that which is neither annihilation nor generation is maintenance, except for a few exceptions. Removing the annihilation and generation rules from the schemata.
+            schemata.remove(rule)
+
+        # change the middle value of the rule to #
+        wildcard_rule = [(rule[0][:3] + "#" + rule[0][4:]), rule[1]]
+        if (
+            wildcard_rule in schemata
+        ):  # check if the annihilation or generation rule is partially in the schemata. Sometimes it is a part of the rule with "#" in the middle and isn't on its own.
+            if (
+                rule[1] in ["0", 0]
+            ):  # if the output of the rule is 0, the corresponding maintenance rule output must also be 0
+                # modify the middle value of schemata(wildcard_rule) to "0"
+                schemata.remove(wildcard_rule)
+                schemata.append(
+                    [wildcard_rule[0][:3] + "0" + wildcard_rule[0][4:], rule[1]]
+                )
+            elif (
+                rule[1] in ["1", 1]
+            ):  # if the output of the rule is 1, the corresponding maintenance rule output must also be 1
+                # modify the middle value of schemata(wildcard_rule) to "1"
+                schemata.remove(wildcard_rule)
+                schemata.append(
+                    [wildcard_rule[0][:3] + "1" + wildcard_rule[0][4:], rule[1]]
+                )
+            else:
+                raise ValueError("Rule output must be 0 or 1")
+    maintenance_rules = schemata
+    return maintenance_rules
+
+
+def fill_missing_outputs_as_maintenance(node: BooleanNode) -> BooleanNode:
+    """
+    Generate a node with missing output values filled as maintenance rules.
+
+    Args:
+        node (BooleanNode) : The node to generate with. The node must contain missing '?' output values.
+
+    Returns:
+        A BooleanNode object with missing output values filled as maintenance rules.
+    """
+
+    # check if there are any missing output values
+    if "?" not in node.outputs:
+        # raise ValueError("There are no missing output values in the node.")
+        return node # removed error to allow for complete functions to pass through smoothly
+    # Replace '?' in generated_node.outputs with 0 or 1 dependint on the middle element of the respective rule
+    lut = node.look_up_table().values.tolist()
+    middle_element = len(lut[0][0]) // 2  # middle input is reduced by 1 since indexing starts from 0
+    new_outputs = []
+    for lut_row in lut:
+        if lut_row[1] == "1":
+            new_outputs.append("1")
+        elif lut_row[1] == "0":
+            new_outputs.append("0")
+        else:
+            new_outputs.append("1" if lut_row[0][middle_element] == "1" else "0")
+    return BooleanNode.from_output_list(new_outputs)
+
+
+def filter_for_ke(generated_nodes, ke, original_ke, epsilon=0.01):
+    """
+    Filter for nodes that are within epsilon of the desired effective connectivity.
+
+    Args:
+    generated_nodes (iterator): List of generated nodes.
+    ke (float): Desired effective connectivity.
+    epsilon (float): Tolerance for effective connectivity.
+
+    Returns:
+    generated_node (BooleanNode): Node that is within epsilon of the desired effective connectivity.
+
+    """
+    generated_node = None
+    closest_node = None
+    closest_ke = None
+
+    for node in generated_nodes:
+        if closest_node is None:
+            closest_node = node
+            closest_ke = node.effective_connectivity()
+            smallest_gap = abs(ke - original_ke)
+        else:
+            ke = node.effective_connectivity()
+            gap = abs(ke - original_ke)
+            if gap < smallest_gap:
+                closest_node = node
+                smallest_gap = gap
+                closest_ke = ke
+
+                if smallest_gap < epsilon:
+                    generated_node = node
+                    yield generated_node
+
+    if generated_node is None:
+        print(
+            f"None found within epsilon. Closest Effective Connectivity: {closest_ke}"
+        )
+        generated_node = closest_node
+        yield generated_node
+
+
+def filter_for_bias(generated_nodes, bias, original_bias, epsilon=0.01):
+    """
+    Filter for nodes that are within epsilon of the desired bias.
+
+    Args:
+    generated_nodes (iterator): List of generated nodes.
+    bias (float): Desired bias.
+    epsilon (float): Tolerance for bias.
+
+    Returns:
+    generated_node (BooleanNode): Node that is within epsilon of the desired bias.
+
+    """
+    generated_node = None
+    closest_node = None
+    closest_bias = None
+
+    for node in generated_nodes:
+        if closest_node is None:
+            closest_node = node
+            smallest_gap = abs(node.bias() - original_bias)
+        else:
+            bias = node.bias()
+            gap = abs(bias - original_bias)
+            if gap < smallest_gap:
+                closest_node = node
+                smallest_gap = gap
+                closest_bias = bias
+
+                if smallest_gap < epsilon:
+                    generated_node = node
+                    yield generated_node
+
+    if generated_node is None:
+        print(f"None found within epsilon. Closest Bias: {closest_bias}")
+        generated_node = closest_node
+        yield generated_node
+
+
+def shuffle_wildcards_in_schemata(schemata):
+    """
+    Shuffle the wildcards in each line of the schemata.
+
+    Args:
+    schemata (list): List of schemata.
+
+    Returns:
+    shuffled_schemata (list): List of shuffled schemata.
+
+    """
+    shuffled_schemata = []
+    for schema, output in schemata:
+        schema = list(schema)
+        random.shuffle(schema)
+        schema = "".join(schema)
+        shuffled_schemata.append([schema, output])
+    return shuffled_schemata
+
+
+def collect_data_from_generator(node_generator, limit=1000, name=None, verbose=False):
+    """
+    Collect data from a node generator.
+
+    Args:
+    node_generator (generator): Generator of nodes.
+    limit (int): Limit of nodes to generate.
+    name (str): Name of the generator.
+    verbose (bool): Verbose output.
+
+    Returns:
+    generated_nodes (list): List of generated nodes.
+    node_bias (list): List of node biases.
+    node_ke (list): List of node effective connectivities.
+    count (int): Count of generated nodes.
+
+    """
+
+    nodes = node_generator
+    count = 0
+    node_bias = []
+    node_ke = []
+    generated_nodes = []
+
+    while True:
+        try:
+            node = next(nodes)
+            generated_nodes.append(node)
+            node_bias.append(node.bias())
+            node_ke.append(node.effective_connectivity())
+            count += 1
+            if count == limit:
+                if verbose:
+                    print(f"Generated {count} nodes for {name}")
+                break
+        except StopIteration:
+            if verbose:
+                print(f"Generated {count} nodes for {name}")
+            break
+    return generated_nodes, node_bias, node_ke, count
+
+
+def combine_output_lists(
+    first_priority_outputs, second_priority_outputs, fill_missing_output_randomly=False
+):
+    """
+    Combine two lists of outputs. Outputs from the first list are given priority.
+
+    Args:
+    first_priority_outputs (list): List of first priority outputs.
+    second_priority_outputs (list): List of second priority outputs.
+
+    Returns:
+    combo_outputs (list): List of combined outputs.
+
+    """
+    # check if both output lengths are the same
+    if len(first_priority_outputs) != len(second_priority_outputs):
+        raise ValueError("Both output lists must be of the same length.")
+    combo_outputs = ["?"] * len(first_priority_outputs)
+
+    for i in range(len(first_priority_outputs)):
+        combo_outputs[i] = (
+            first_priority_outputs[i] if first_priority_outputs[i] != "?" else "?"
+        )
+        if combo_outputs[i] == "?":
+            if fill_missing_output_randomly:
+                combo_outputs[i] = (
+                    second_priority_outputs[i]
+                    if second_priority_outputs[i] != "?"
+                    else random.choice(
+                        ["0", "1"]
+                    )  # this will fill the missing outputs randomly
+                )
+            else:
+                combo_outputs[i] = (
+                    second_priority_outputs[i]
+                    if second_priority_outputs[i] != "?"
+                    else "?"  # this will keep the missing outputs as '?'
+                )
+    return combo_outputs
+
+
+def shuffle_and_generate(
+    automata_output_list: dict,
+    shuffle: str = "schemata",
+    combine: str = "outputs",
+    limit=None,
+):
+    """
+    Shuffle the schemata and generate new nodes.
+
+    Args:
+    automata_output_list (dict): Dictionary of automata outputs.
+    shuffle (str): Type of shuffle. Can be 'schemata' or 'maintenance'.
+    combine (str): Type of combine. Can be 'schemata' or 'outputs'.
+    limit (int): Limit of nodes to generate.
+
+    Returns:
+    A generator of shuffled nodes.
+    """
+
+    # get all relevant parent rule data
+    parent_node = BooleanNode.from_output_list(automata_output_list)
+
+    while True:
+        if shuffle == "schemata":
+            shuffled_schemata = shuffle_wildcards_in_schemata(
+                parent_node.schemata_look_up_table().values.tolist()
+            )
+            shuffled_node = BooleanNode.from_partial_lut(
+                shuffled_schemata, fill_clashes=True, fill_missing_output_randomly=True
+            )
+            yield shuffled_node
+
+        elif shuffle == "maintenance":
+            # get the annihilation generation rules and maintenance rules
+            anni_gen_schemata = annihilation_generation_rules(automata_output_list)
+            maintenance_schemata = maintenance_rules(automata_output_list)
+
+            # shuffle schemata and combine with annihilation generation rules
+            shuffled_schemata = shuffle_wildcards_in_schemata(maintenance_schemata)
+
+            # combine the schemata TODO: [SRI] combine via schemata and ensure that first priority schemata are maintained
+            if combine == "schemata":
+                # combining the shuffled schemata with the annihilation generation rules doesn't preserve the annihilation generation rules in the current version of the code.
+                combo = (
+                    anni_gen_schemata + shuffled_schemata
+                )  # put anni_gen first because clashing outputs will prefer the first one. this will prefer annihilation generation in the shuffled nodes.
+                shuffled_node = BooleanNode.from_partial_lut(
+                    combo, fill_clashes=True, fill_missing_output_randomly=True
+                )
+                yield shuffled_node
+            elif (
+                combine == "outputs"
+            ):  # NOTE: [SRI] This is option preserves the annihilation generation rules in the shuffled nodes. But needs to be tested more.
+                # combine the outputs
+                anni_gen_lut_outputs = BooleanNode.from_partial_lut(
+                    anni_gen_schemata
+                ).outputs
+                shuffled_lut_outputs = BooleanNode.from_partial_lut(
+                    shuffled_schemata, fill_clashes=True
+                ).outputs
+                combo = combine_output_lists(
+                    anni_gen_lut_outputs,
+                    shuffled_lut_outputs,
+                    fill_missing_output_randomly=True,
+                )
+                shuffled_node = BooleanNode.from_output_list(combo)
+                yield shuffled_node
+
+        else:
+            raise ValueError(
+                "Invalid shuffle type. Must be 'schemata' or 'maintenance'."
+            )
+
+        if limit is not None:
+            if limit == 0:
+                break
+            limit -= 1
+        # yield shuffled_node
+
+
+def min_max_and_parent_rule_values(
+    automata_output_list: dict,
+    values: dict,
+    value_type: str = "ke",
+    include_parent=True,
+):
+    """
+    Get the min and max values for the histograms and the parent rule values.
+
+    Args:
+    automata_output_list (dict): Dictionary of automata outputs.
+    values (dict): Dictionary of node values.
+    parent_value_type (str): Type of parent value. Can be 'ke' or 'bias'.
+
+    Returns:
+    min_max (list): List of min and max values for the histograms.
+    parent_rule_values (dict): Dictionary of parent rule values.
+
+    """
+
+    min_max = []
+    parent_rule_values = {}
+    for item in values:
+        if include_parent:
+            parent_node = BooleanNode.from_output_list(automata_output_list[item])
+            if value_type == "ke":
+                parent_rule_values[item] = parent_node.effective_connectivity()
+            elif value_type == "bias":
+                parent_rule_values[item] = parent_node.bias()
+            else:
+                print("Invalid parent_value_type. Must be 'ke' or 'bias'.")
+
+        min_max.append(min(values[item]))
+        min_max.append(max(values[item]))
+    if include_parent:
+        min_max.append(min(parent_rule_values.values()) * 0.98)
+        min_max.append(max(parent_rule_values.values()) * 1.02)
+    min_max = [min(min_max), max(min_max)]
+
+    if include_parent:
+        return min_max, parent_rule_values
+    else:
+        return min_max
+
+
+# def plot_hist(
+#     generated_node_values,
+#     value_type=None,
+#     no_of_columns=4,
+#     title=None,
+#     save=False,
+#     filename=None,
+#     include_parent=False,
+# ) -> None:
+#     """
+#     Plot histogram of generated node values.
+
+#     Args:
+#     generated_node_values (dict): Dictionary of generated node values.
+#     value_type (str): Type of value to plot. Must be 'ke' or 'bias'.
+#     no_of_columns (int): Number of columns in the plot.
+
+#     Returns:
+#     None
+
+#     Example:
+#     generated_node_values = {
+#         "Rule 1": [0.1, 0.2, 0.3, 0.4, 0.5],
+#         "Rule 2": [0.2, 0.3, 0.4, 0.5, 0.6],
+#     }
+#     plot_hist(generated_node_values, value_type='ke')
+#     """
+
+#     if value_type == "ke":
+#         parent_rule_label = "Parent Rule $K_e$"
+#         xlabel = "Effective Connectivity"
+#         ylabel = "Count"
+#     elif value_type == "bias":
+#         parent_rule_label = "Parent Rule Bias"
+#         xlabel = "Bias"
+#         ylabel = "Count"
+#     elif type(value_type) is not str and value_type not in ["ke", "bias"]:
+#         xlabel = value_type
+#         ylabel = "Count"
+#     else:
+#         raise ValueError("Invalid value_type. Must be 'ke' or 'bias'.")
+#     if title is None:
+#         title = f"Distribution of Generated {value_type.capitalize()} Values"
+
+#     total_plots = len(generated_node_values)
+#     no_of_rows = int((total_plots / no_of_columns) + 1)
+#     # plot hist ke in subplots
+#     fig, axs = plt.subplots(no_of_rows, no_of_columns, figsize=(25, 15))
+#     fig.suptitle(
+#         title,
+#         fontsize=25,
+#     )
+#     min_max, parent_rule_values = min_max_and_parent_rule_values(
+#         automata_output_list,
+#         generated_node_values,
+#         value_type=value_type,
+#         include_parent=include_parent,
+#     )
+#     for i, rule in enumerate(generated_node_values):
+#         ax = axs.flatten()[i]
+#         # make each subplot axes equal in value range
+#         ax.set_xlim(min_max)
+#         # ax.set_ylim(0, max_count)
+
+#         ax.hist(generated_node_values[rule], bins=100, color="blue", alpha=0.7)
+#         ax.set_title(rule, fontsize=20)
+#         ax.set_xlabel(xlabel)
+#         ax.set_ylabel(ylabel)
+#         ax.text(
+#             0.2,
+#             0.9,
+#             f"Total Count: {len(generated_node_values[rule])}",
+#             horizontalalignment="center",
+#             verticalalignment="center",
+#             transform=ax.transAxes,
+#             fontsize=10,
+#         )
+
+#         if parent_rule_values and parent_rule_label:
+#             # plot parent rule value as a line
+#             ax.axvline(
+#                 parent_rule_values[rule],
+#                 color="red",
+#                 linestyle="--",
+#                 label=f"{parent_rule_label}: {parent_rule_values[rule]:.2f}",
+#             )
+#             # ax.text(
+#             #     parent_rule_values[rule],
+#             #     .5,
+#             #     f"{parent_rule_values[rule]:.2f}",
+#             #     rotation=90,
+#             #     fontsize=10,
+#             # )
+
+#             ax.legend(fontsize="large", loc="upper right")
+
+#     plt.tight_layout()
+#     plt.subplots_adjust(top=0.92)
+#     if save:
+#         plt.savefig(filename)
+#     plt.show()
+
+
+# def plot_scatter(
+#     first_values,
+#     second_values,
+#     label: list[str, str] = ["ke", "bias"],
+#     no_of_columns=4,
+#     title=None,
+#     save=False,
+#     filename=None,
+#     include_parent=False,
+# ) -> None:
+#     """
+#     Plot scatter plot of generated rules.
+
+#     Args:
+#     first_values (dict): Dictionary of first values.
+#     second_values (dict): Dictionary of second values.
+#     label (list): List of labels. Must be 'ke' or 'bias'.
+#     no_of_columns (int): Number of columns in the plot.
+
+#     Returns:
+#     None
+
+#     Example:
+#     first_values = {
+#         "Rule 1": [0.1, 0.2, 0.3, 0.4, 0.5],
+#         "Rule 2": [0.2, 0.3, 0.4, 0.5, 0.6],
+#     }
+#     second_values = {
+#         "Rule 1": [0.2, 0.3, 0.4, 0.5, 0.6],
+#         "Rule 2": [0.3, 0.4, 0.5, 0.6, 0.7],
+#     }
+#     plot_scatter(first_values, second_values, label=['ke', 'bias'])
+#     """
+#     if label[0] == label[1]:
+#         raise ValueError("Invalid labels. Must be different.")
+#     if label[0] == "ke":
+#         xlabel = "$K_e$"
+#         if label[1] == "bias":
+#             ylabel = "Bias"
+
+#     elif label[0] == "bias":
+#         xlabel = "Bias"
+#         if label[1] == "ke":
+#             ylabel = "$K_e$"
+#     else:
+#         raise ValueError("Invalid labels. Must be 'ke' or 'bias'.")
+
+#     if title is None:
+#         title = f"Scatter plot of {xlabel} and {ylabel} of generated rules."
+
+#     total_plots = len(first_values)
+#     no_of_rows = (
+#         int((total_plots / no_of_columns) + 1) if total_plots > no_of_columns else 1
+#     )
+
+#     fig, axs = plt.subplots(no_of_rows, no_of_columns, figsize=(25, 15))
+#     fig.suptitle(
+#         title,
+#         fontsize=25,
+#     )
+#     min_max_x, parent_rule_values_x = min_max_and_parent_rule_values(
+#         automata_output_list,
+#         first_values,
+#         value_type=label[0],
+#         include_parent=include_parent,
+#     )
+#     min_max_y, parent_rule_values_y = min_max_and_parent_rule_values(
+#         automata_output_list,
+#         second_values,
+#         value_type=label[1],
+#         include_parent=include_parent,
+#     )
+#     # plot scatter if first value and second value for
+#     rules = list(first_values.keys())
+#     for i, rule in enumerate(rules):
+#         ax = axs[int(i / no_of_columns), i % no_of_columns]  # TODO: [SRI] Fix the indexing
+
+#         ax.scatter(
+#             first_values[rule],
+#             second_values[rule],
+#             label=f"Rule {rule}",
+#             alpha=0.5,
+#         )
+
+#         ax.set_title(f"Rule {rule}")
+#         ax.set_xlabel(xlabel)
+#         ax.set_ylabel(ylabel)
+#         ax.grid()
+#         ax.set_xlim(min_max_x)
+#         ax.set_ylim(min_max_y)
+
+#         # plot parent rule values
+#         ax.scatter(parent_rule_values_x[rule], parent_rule_values_y[rule], c="red")
+#         ax.legend()
+
+#     for i in range(total_plots, no_of_columns * no_of_rows):
+#         fig.delaxes(axs[int(i / no_of_columns), i % no_of_columns])
+#     plt.tight_layout()
+#     if save:
+#         plt.savefig(filename)
+#     plt.show()
diff --git a/cana/boolean_network.py b/cana/boolean_network.py
index 5b26f6e..8cd9a6b 100644
--- a/cana/boolean_network.py
+++ b/cana/boolean_network.py
@@ -545,7 +545,7 @@ def effective_graph(self, bound="mean", threshold=None):
                 self._eg = nx.DiGraph(
                     name="Effective Graph: "
                     + self.name
-                    + "(Threshold: {threshold:.2f})".format(threshold=threshold)
+                    + f"(Threshold: {threshold:.2f})".format(threshold=threshold)
                 )
             else:
                 self._eg = nx.DiGraph(
diff --git a/cana/boolean_node.py b/cana/boolean_node.py
index 8d7db0b..9431527 100644
--- a/cana/boolean_node.py
+++ b/cana/boolean_node.py
@@ -30,10 +30,16 @@
     outputs_to_binstates_of_given_type,
     statenum_to_binstate,
 )
+from cana.cboolean_node import (
+    input_symmetry_mean_annigen_fast as _input_symmetry_mean_annigen_fast,
+    input_symmetry_mean_fast as _input_symmetry_mean_fast,
+)
+
 from cana.utils import input_monotone, ncr, fill_out_lut
 import random
 import warnings
-from math import comb
+from math import comb, fsum
+from collections import defaultdict
 
 
 class BooleanNode(object):
@@ -321,6 +327,12 @@ def effective_connectivity(self, operator=mean, norm=True):
         See Also:
             :func:`input_redundancy`, :func:`input_symmetry`, :func:`~cana.boolean_network.BooleanNetwork.effective_graph`.
         """
+        # checking for '?' values in the outputs
+        if "?" in self.outputs:
+            raise ValueError(
+                "The look-up table contains '?' values. The effective connectivity cannot be computed."
+            )
+
         k_r = self.input_redundancy(operator=operator, norm=False)
         #
         k_e = self.k - k_r
@@ -399,16 +411,28 @@ def input_symmetry_mean(self):
         Returns:
             (float)
         """
-        summand = 0
-        # fTheta = a list of TS
-        for fTheta in self._ts_coverage.values():
-            inner = 0
-            for ts in fTheta:
-                inner += sum(
-                    len(i) for i in ts[1]
-                )  # assumes that indicies will ever only be in at most 1 group
-            summand += inner / len(fTheta)
-        return summand / 2**self.k
+        self._check_compute_canalization_variables(ts_coverage=True)
+
+        ts_coverage = self._ts_coverage
+        if not ts_coverage:
+            return 0.0
+
+        # if _input_symmetry_mean_fast is not None:
+        return _input_symmetry_mean_fast(ts_coverage, self.k)
+
+        # numerator = 0.0
+        # inv_total_states = 1.0 / (1 << self.k)
+
+        # for f_theta in ts_coverage.values():
+        #     if not f_theta:
+        #         continue
+        #     inv_len = 1.0 / len(f_theta)
+        #     total = 0
+        #     for ts in f_theta:
+        #         for group in ts[1]:
+        #             total += len(group)
+        #     numerator += total * inv_len
+        # return numerator * inv_total_states
 
     def look_up_table(self):
         """Returns the Look Up Table (LUT)
@@ -439,7 +463,19 @@ def look_up_table(self):
         return df
 
     def schemata_look_up_table(
-        self, type="pi", pi_symbol="#", ts_symbol_list=["\u030a", "\u032f"]
+        self,
+        type="pi",
+        pi_symbol="#",
+        ts_symbol_list=[
+            "\u030a",  # Ring above
+            "\u032f",  # Inverted breve below
+            "\u0303",  # Tilde
+            "\u0304",  # Macron
+            "\u0305",  # Overline
+            "\u0306",  # Breve
+            "\u0307",  # Dot above
+            "\u0308",  # Diaeresis
+        ],
     ):
         """Returns the simplified schemata Look Up Table (LUT)
 
@@ -944,15 +980,16 @@ def input_signs(self):
 
         return input_sign_list
 
+    @classmethod
     def from_partial_lut(
-        partial_lut,
-        fill_missing_output_randomly=False,
-        required_node_bias=None,
-        required_effective_connectivity=None,
-        verbose=False,
-        *args,
-        **kwargs,
-    ):
+        self,
+        partial_lut: list,
+        fill_missing_output_randomly: bool = False,
+        fill_clashes: bool = False,
+        verbose: bool = False,
+        *args,  # keeping this because it is used in the from_output_list method. I don't know what it does.
+        **kwargs,  # same as above
+    ) -> "BooleanNode":
         """
         Instantiate a Boolean Node from a partial look-up table.
 
@@ -961,6 +998,7 @@ def from_partial_lut(
         Args:
             partial_lut (list) : A partial look-up table of the node.
             fill_missing_output_randomly (bool) : If True, missing output values are filled with random 0 or 1. If False, missing output values are filled with '?'.
+            fill_clashes (bool) : If True, fill the clashing output values with the first value in the list. If False, raise an error.
             verbose (bool) : If True, print additional information.
 
         Returns:
@@ -977,7 +1015,9 @@ def from_partial_lut(
 
         """
 
-        generated_lut = fill_out_lut(partial_lut, verbose=False)
+        generated_lut = fill_out_lut(
+            partial_lut, fill_clashes=fill_clashes, verbose=verbose
+        )
         output_list = [x[1] for x in generated_lut]
 
         generated_node = BooleanNode.from_output_list(output_list, *args, **kwargs)
@@ -991,17 +1031,45 @@ def from_partial_lut(
                 for output in generated_node.outputs
             ]
 
-        if verbose and "?" in generated_node.outputs:
-            print(
-                "The LUT is incomplete. Missing values are represented by '?'."
-                if verbose
-                else None
-            )
+        if verbose and ("?" in generated_node.outputs):
+            print("The LUT is incomplete. Missing values are represented by '?'.")
         return generated_node
 
+    def fill_missing_output_randomly(self, limit=None):
+        """
+        Generate a node with missing output values filled randomly.
+
+        Args:
+            node (BooleanNode) : The node to generate with. The node must contain missing '?' output values.
+
+        Returns:
+            A Generator of BooleanNode objects with missing output values filled randomly.
+
+        Example:
+            >>> BooleanNode.fill_missing_output_randomly(limit=10)
+        """
+        generated_node = self
+
+        # check if there are any missing output values
+        if "?" not in generated_node.outputs:
+            raise ValueError("There are no missing output values in the node.")
+
+        # Replace '?' in generated_node.outputs with 0 or 1 randomly
+        while True:
+            new_outputs = [
+                random.choice(["0", "1"]) if output == "?" else output
+                for output in generated_node.outputs
+            ]
+            yield BooleanNode.from_output_list(new_outputs)
+
+            if limit is not None:
+                if limit == 0:
+                    break
+                limit -= 1
+
     def generate_with_required_bias(
         self,
-        required_node_bias=None,
+        bias=None,
         verbose=False,
         *args,
         **kwargs,
@@ -1011,29 +1079,30 @@ def generate_with_required_bias(
         This node takes a boolean node with "?" output values and generates all possible nodes with the missing output values filled to achieve the required bias as closely as possible.
 
         Args:
-            required_node_bias (float) : The required node bias to fill the missing output values with.
+            bias (float) : The required node bias to fill the missing output values with.
             verbose (bool) : If True, print additional information.
 
         Returns:
             A Generator of BooleanNode objects with the required bias.
 
         Example:
-            >>> BooleanNode.generate_with_required_bias(required_node_bias=0.5, verbose=True, name="EG")
+            >>> BooleanNode.generate_with_required_bias(bias=0.5, verbose=True, name="EG")
 
         Note:
             The required node bias should be a float value between 0 and 1.
-
         """
         generated_node = self
-        bias = required_node_bias  # making a copy for print statement at the end of function
-        # Checking if more than one out of required_effective_connectivity, requried_node_bias and fill_missing_output_randomly are True, then raise an error.
-        if required_node_bias is None:
+        bias_for_print = (
+            bias  # making a copy for print statement at the end of function
+        )
+        # Checking if more than one out of effective_connectivity, requried_node_bias and fill_missing_output_randomly are True, then raise an error.
+        if bias is None:
             raise ValueError(
                 "Please specify the required node bias to generate the node with the required bias."
             )
 
         if (
-            required_node_bias is not None
+            bias is not None
         ):  # If required node bias is specified, then fill missing output values with the specified bias.
             # Checking if required node bias is within the achievable bias range of the node.
 
@@ -1046,30 +1115,30 @@ def generate_with_required_bias(
             )
 
             # Calculating the number of '1' required to achieve the required bias.
-            required_ones = int(required_node_bias * 2**generated_node.k)
+            required_ones = int(bias * 2**generated_node.k)
             current_ones = generated_node.outputs.count("1")
 
             min_achievable_bias = current_ones / 2**generated_node.k
             min = False  # flag to check if the required bias is less than the minimum achievable bias.
             # Checking if the required bias is achievable.
-            if required_node_bias > max_achievable_bias:
+            if bias > max_achievable_bias:
                 if verbose:
                     warnings.warn(
                         f"Required Node Bias is greater than the maximum achievable bias ({max_achievable_bias}) of the node. Generating with the maximum achievable bias."
                     )
-                required_node_bias = max_achievable_bias
+                bias = max_achievable_bias
 
-            elif required_node_bias < min_achievable_bias:
+            elif bias < min_achievable_bias:
                 if verbose:
                     warnings.warn(
                         f"Required Node Bias is lower than the minimum achievable bias ({min_achievable_bias}) of the node. Generating with the minimum achievable bias."
                     )
-                required_node_bias = min_achievable_bias
+                bias = min_achievable_bias
                 min = True
 
             # Fill the missing output values to achieve the required bias as closely as possible.
             required_ones = int(
-                required_node_bias * 2**generated_node.k
+                bias * 2**generated_node.k
             )  # recalculating in case the required bias was adjusted in the above steps.
             ones_to_be_generated = required_ones - current_ones
             number_of_missing_values = generated_node.outputs.count("?")
@@ -1083,7 +1152,7 @@ def generate_with_required_bias(
 
             def unique_permutations_missing_values(elements, n):
                 """
-                Generate n unique permutations of elements.
+                Generate n unique permutations of elements. Shuffle the elements till a new arrangement is found. 
                 """
                 seen = set()
 
@@ -1102,7 +1171,9 @@ def unique_permutations_missing_values(elements, n):
             )
             generated_node_permutations = []
 
-            def node_permutations(combinations, node_outputs, *args, **kwargs):
+            def node_permutations(
+                combinations, node_outputs, missing_output_indices, *args, **kwargs
+            ):
                 """
                 Applying the generated combinations to the missing output values and generating the BooleanNode objects.
                 """ 
@@ -1110,15 +1181,20 @@ def node_permutations(combinations, node_outputs, *args, **kwargs):
                 for combination in combinations:
                     combination = list(combination)
                     generated_outputs = node_outputs.copy()
-                    for i, output in enumerate(node_outputs):
-                        if output == "?":
-                            generated_outputs[i] = combination.pop()
+                    for index in missing_output_indices:
+                        generated_outputs[index] = combination.pop()
                     yield BooleanNode.from_output_list(
                         generated_outputs, *args, **kwargs
                     )
 
+            node_outputs = generated_node.outputs
+            missing_output_indices = [i for i, x in enumerate(node_outputs) if x == "?"]
             generated_node_permutations = node_permutations(
-                combinations, generated_node.outputs, *args, **kwargs
+                combinations,
+                node_outputs=node_outputs,
+                missing_output_indices=missing_output_indices,
+                *args,
+                **kwargs,
             )
 
             output_bias_for_print = (
@@ -1127,18 +1203,19 @@ def node_permutations(combinations, node_outputs, *args, **kwargs):
             if verbose:
                 if min:
                     print(
-                        f"{combinationsnumber:.2e} possible permutation(s) with a bias of {output_bias_for_print}. This is the closest achievable bias to the required bias of {bias}."
+                        f"{combinationsnumber:.2e} possible permutation(s) with a bias of {output_bias_for_print}. This is the closest achievable bias to the required bias of {bias_for_print}."
                     )
                 else:
                     print(
-                        f"{combinationsnumber:.2e} possible permutation(s) with a bias of {output_bias_for_print}. This is the closest bias less than or equal to the required bias of {bias}."
+                        f"{combinationsnumber:.2e} possible permutation(s) with a bias of {output_bias_for_print}. This is the closest bias less than or equal to the required bias of {bias_for_print}."
                     )
             return generated_node_permutations  # returning a generator of BooleanNode objects with the required bias.
 
     def generate_with_required_effective_connectivity(
         self,
-        required_effective_connectivity=None,
-        # limit=50,
+        effective_connectivity=None,
+        epsilon=0.01,
+        shuffle=False,  # depending on required effective connectivity, this can be faster or slower.
         verbose=False,
         *args,
         **kwargs,
@@ -1148,58 +1225,514 @@ def generate_with_required_effective_connectivity(
         This node takes a boolean node with "?" output values and generates all possible nodes with the missing output values filled to achieve the required effective connectivity as closely as possible.
 
         Args:
-            required_effective_connectivity (float) : The required effective connectivity to fill the missing output values with. It will generate a node with the closest possible effective connectivity to the required effective connectivity.
+            effective_connectivity (float) : The required effective connectivity to fill the missing output values with. It will generate a node with the closest possible effective connectivity to the required effective connectivity.
             verbose (bool) : If True, print additional information.
 
         Returns:
             (BooleanNode) : the instantiated object.
 
         Example:
-            >>> BooleanNode.generate_with_required_effective_connectivity(required_effective_connectivity=0.5, verbose=True, name="EG")
+            >>> BooleanNode.generate_with_required_effective_connectivity(effective_connectivity=0.5, verbose=True, name="EG")
 
         Note:
             The required effective connectivity should be a float value between 0 and 1.
 
-        # TODO : [SRI] to  cover the entire space of permutations evenly, what if i fill each node randomly and calculate the effective connectivity . then add them to a list of all nodes with sufficiently close effective connectivity? This option will only be activated if the calculated permutation space goes beyond a predecided threshold.
         """
 
+        if effective_connectivity is None:
+            raise ValueError("Please provide a required effective connectivity value.")
+
         generated_node = self
-        if required_effective_connectivity is not None:
-            generated_outputs = generated_node.outputs.copy()
-            missing_output_indices = [
-                i for i, x in enumerate(generated_outputs) if x == "?"
-            ]
-            # print(f"Missing output indices = {missing_output_indices}." if verbose else None)
+        generated_outputs = generated_node.outputs.copy()
+        missing_output_count = generated_outputs.count("?")
+        if verbose:
+            print(f"No. of '?' in output = {missing_output_count}.")
 
-            missing_output_count = generated_outputs.count("?")
-            # print(f"No. of '?' in output = {missing_output_count}.")
-            missing_permutations = list(product(*[("0", "1")] * (missing_output_count)))
-            # print(permutations)
-            generated_node_permutations = [None] * len(missing_permutations)
+        missing_output_indices = [
+            i for i, x in enumerate(generated_outputs) if x == "?"
+        ]
+
+        missing_permutations = product(*[("0", "1")] * (missing_output_count))
+
+        generated_node_permutations = []
 
-            for count, missing_permutation in enumerate(missing_permutations):
+        def permutations_with_ec(
+            missing_permutations,
+            missing_output_indices,
+            generated_outputs,
+            effective_connectivity=effective_connectivity,
+            epsilon=epsilon,
+            shuffle=shuffle,
+            *args,
+            **kwargs,
+        ):
+            """
+            applying all permutations of 1's and 0's to '?' values in the output list.
+            Generating a BooleanNode object with evert permutation and checking if its effective connectivity is close enough to the required effective connectivity.
+            Returning a generator of all nodes with close enough required effective connectivity.
+            """
+            # count = 0  # counting number of nodes generated till a suitable one is found. To understand how the search space is being traversed.
+            found_at_least_one = False
+            closest_ec_node = None
+            for perm in missing_permutations:
+                # count += 1
+
+                # shuffling the permutation to access the entire search space randomly. Turn off if not needed. NOTE: shuffle is faster for certain required K_e values.
+                if shuffle:
+                    perm = list(perm)
+                    random.shuffle(perm)
+
+                output = generated_outputs.copy()
                 for i, index in enumerate(missing_output_indices):
-                    generated_outputs[index] = missing_permutation[i]
-                generated_node_permutations[count] = BooleanNode.from_output_list(
-                    generated_outputs, *args, **kwargs
-                )  # generating a list of nodes with all possible permutations of the missing output values.
+                    output[index] = perm[i]
 
-            # print(f"Total output permutations generated = {len(generated_node_permutations)}.")
+                node = BooleanNode.from_output_list(output, *args, **kwargs)
+                if (
+                    node.is_within_tolerance(
+                        effective_connectivity=effective_connectivity,
+                        epsilon=epsilon,
+                    )
+                    is True
+                ):
+                    # print(count)
+                    # count = 0
+                    found_at_least_one = True  # we found at least one node within epsilon. there is now no need to find the closest possible one.
 
-            permutation_effective_connectivity = [
-                x.effective_connectivity() for x in generated_node_permutations
-            ]
-            closest_value = min(
-                permutation_effective_connectivity,
-                key=lambda x: abs(x - required_effective_connectivity),
-            )
-            closest_index = permutation_effective_connectivity.index(closest_value)
+                    yield node
+
+                if found_at_least_one is False:
+                    # if we can't find a single rule within epsilon, let's return the closest possible one.
 
-            generated_node = generated_node_permutations[closest_index]
+                    if closest_ec_node is None:
+                        closest_ec_node = node
+                        smallest_gap = abs(
+                            node.effective_connectivity() - effective_connectivity
+                        )
+                    else:
+                        gap = abs(
+                            node.effective_connectivity() - effective_connectivity
+                        )
+                        if gap < smallest_gap:
+                            closest_ec_node = node
+                            smallest_gap = gap
+                        # else:
+                        #     continue
+                # else:
+                #     continue
+
+            if found_at_least_one is False:
+                warnings.warn(
+                    f"No node within {epsilon} of {effective_connectivity} (required effective connectivity) found.\nGenerating a node with the closest effective connectivity of {closest_ec_node.effective_connectivity()}"
+                )
+                yield closest_ec_node
+
+        generated_node_permutations = permutations_with_ec(
+            missing_permutations,
+            missing_output_indices,
+            generated_outputs,
+            effective_connectivity,
+            epsilon=epsilon,
+            *args,
+            **kwargs,
+        )
+
+        if verbose:
             print(
-                f"Generated the node with the closest possible effective connectivity of {generated_node.effective_connectivity()}."
-                if verbose
-                else None
+                f"Returning a generator of nodes with effective connectivity within {epsilon} of {effective_connectivity}."
             )
 
-        return generated_node
+        return generated_node_permutations  # returning a generator of BooleanNode objects with close enough effective connectivity.
+
+    def is_within_tolerance(self, effective_connectivity=None, bias=None, epsilon=0.01):
+        """
+        Check if the node's effective connectivity or bias is within the required tolerance.
+
+        Args:
+            effective_connectivity (float) : The required effective connectivity value.
+            required_bias (float) : The required bias value.
+            epsilon (float) : The tolerance value.
+
+        Returns:
+            (bool) : True if the node's effective connectivity or bias (or both, if both are specified) is within the required tolerance, False otherwise.
+
+        """
+        if (effective_connectivity is None) and (bias is None):
+            raise ValueError(
+                "Please provide a required effective connectivity value or required bias."
+            )
+
+        if effective_connectivity is not None:
+            if abs(self.effective_connectivity() - effective_connectivity) < epsilon:
+                result = True
+            else:
+                result = False
+
+        if bias is not None:
+            if abs(self.bias() - bias) < epsilon:
+                result = True
+            else:
+                result = False
+
+        return result
+
+    def get_annihilation_generation_rules(
+        self, type: str = "wildcard", split: bool = False
+    ) -> list:
+        """
+        Get the annihilation and generation rules of the node.
+        The annihilation rules are the rules that output 0 when the middle input is 1.
+        The generation rules are the rules that output 1 when the middle input is 0.
+
+
+        Args:
+            split (bool) : If True, return the annihilation and generation rules separately. If False, return the annihilation and generation rules together.
+            type (str) : The type of coverage function to use. Options are 'wildcard' and 'ts', where 'ts' is the two-symbol version.
+
+        Returns:
+            (list) : A list of annihilation and generation rules. If 'ts' is selected, the list contains the input and two-symbol indices for each rule.
+
+        Method:
+            Creates a Look_up_table for the node.
+            It generates new lookup tables for annihilation(using logic [RULE & (NOT X_4)]) and generation(using logic [NOT RULE & (X_4)]).
+            The rows that output 1 in the new schematas are the annihilations and generations.
+            We combine the two dataframes to get the final dataframe. We reassign the annihilation output to 0. We reassign the generation output to 1.
+            We return the final dataframe as a list.
+
+        Example:
+            >>> get_annihilation_generation_rules(type='wildcard', split=False)
+            [('0##1##0', 0), ('0#01###', 0), ('0##10##', 0), ('1##0##1', 1), ('##10##1', 1), ('###01#1', 1)]
+
+            >>> get_annihilation_generation_rules(type='ts', split=False)
+            [['0#01###', [[2, 4, 6]]], ['1##0##1', [[0, 2, 4]]]], where inputs with indicies 2,4,6 in the first rule are interchangeable and inputs with indicies 0,2,4 in the second rule are interchangeable.
+
+
+        """
+
+        if type not in ["wildcard", "ts"]:
+            raise ValueError("Invalid type. Expected 'wildcard' or 'ts'.")
+
+        lut = self.look_up_table()
+        annihilation_outputs_lut = (  # generates an LUT which is RULE & (NOT X_4), where X_4 is the middle input. the result is 1 for all the rules that annihilate and 0 for all the others.
+            ((lut["Out:"] == "0") & (lut["In:"].str[3] == "1"))
+            .apply(lambda x: "1" if x else "0")
+            .tolist()
+        )
+        generation_outputs_lut = (  # generates an LUT which is NOT RULE & (X_4), where X_4 is the middle input. the result is 1 for all the rules that generate and 0 for all the others.
+            ((lut["Out:"] == "1") & (lut["In:"].str[3] == "0"))
+            .apply(lambda x: "1" if x else "0")
+            .tolist()
+        )
+
+        annihilation = BooleanNode.from_output_list(annihilation_outputs_lut)
+        generation = BooleanNode.from_output_list(generation_outputs_lut)
+
+        if type == "wildcard":
+            annihilation._check_compute_canalization_variables(prime_implicants=True)
+            generation._check_compute_canalization_variables(prime_implicants=True)
+
+            # get the prime implicants for the annihilation and generation
+            pia = annihilation._prime_implicants.get("1", [])
+            pig = generation._prime_implicants.get("1", [])
+
+            anni_schemata = []
+            gen_schemata = []
+            for item in pia:
+                anni_schemata.append((item, 0))
+            for item in pig:
+                gen_schemata.append((item, 1))
+            if split:
+                return anni_schemata, gen_schemata
+            return anni_schemata + gen_schemata
+
+        elif type == "ts":
+            generation._check_compute_canalization_variables(two_symbols=True)
+            annihilation._check_compute_canalization_variables(two_symbols=True)
+
+            # get the two-symbol logic
+            tsa = annihilation._two_symbols[1]
+            tsg = generation._two_symbols[1]
+
+            # replace 2 with # (other all ts coverage functions are built with '2' for wildcard)
+            tsa = [
+                [
+                    item.replace("2", "#") if isinstance(item, str) else item
+                    for item in sublist
+                ]
+                for sublist in tsa
+            ]
+            tsg = [
+                [
+                    item.replace("2", "#") if isinstance(item, str) else item
+                    for item in sublist
+                ]
+                for sublist in tsg
+            ]
+
+            # keep only schemata inputs and the two symbol indices for each row
+            tsa = [sublist[:2] for sublist in tsa]
+            tsg = [sublist[:2] for sublist in tsg]
+            if split:
+                return tsa, tsg
+            return tsa + tsg
+    
+    def input_symmetry_mean_anni_gen(self, norm = False):
+        """
+        Input symmetry for the annihilation and generation rules of the node.
+        The mean of the number of input values that are # for all annihilation and generation rules.
+
+        Returns:
+            (float) : The mean of the number of input values that are # for all annihilation and generation rules.
+
+        """
+        ts_coverage = self.get_anni_gen_coverage(type="ts")
+        # if _input_symmetry_mean_annigen_fast is not None:
+        result = _input_symmetry_mean_annigen_fast(ts_coverage)
+        # else:
+        #     coverage_values = [f_theta for f_theta in ts_coverage.values() if f_theta]
+
+        #     if not coverage_values:
+        #         return 0.0
+
+        #     summand = fsum(
+        #         fsum(len(group) for ts in f_theta for group in ts[1]) / len(f_theta)
+        #         for f_theta in coverage_values
+        #     )
+
+        #     result = summand / len(coverage_values)
+        if norm:
+            return result / self.k
+        return result
+
+    def get_anni_gen_coverage(self, type="wildcard"):
+        """
+        Computes the coverage of the annihilation and generation functions of the BooleanNode.
+        This is different from the pi_coverage() and ts_coverage() which compute regular prime implicant and two-symbol coverage.
+
+        The coverage is computed in two ways:
+        1. wildcard: computes the wildcard schemata that cover the LUT entries.
+        2. ts: computes the two-symbol schemata that cover the LUT entries.
+
+        Parameters:
+        -----------
+        n: BooleanNode
+            The BooleanNode for which the coverage is computed.
+        type: str
+            The type of coverage to compute. Can be either 'wildcard' or 'ts'.
+
+        Returns:
+        --------
+        For type='wildcard':
+            A dict: Keys- LUT entries in binary format, Values- the wildcard schemata that covers the LUT entry.
+
+            Example:
+            '0100100': {'#1#01#0', '#1#010#', '#1001##'},
+
+        For type='ts':
+            A dict: Keys- LUT entries in binary format, Values- the two symbol schemata that covers the LUT entry.
+
+            Example:
+                '0011010': [
+                ['0021210', [], [[0, 1, 6], [3, 5], [2, 4]]],
+                ['2121020', [[1, 5]], [[4, 6], [1, 3], [0, 2, 5]]]
+                ]
+                Here, the LUT entry 0011010 is covered by two schemata. The first schema is 0021210 with no ts-indices, zero-indices are [0, 1, 6], one-indices are [3, 5] and wildcard-indices are [2, 4]. The second schema is 2121020 with ts-indices [1, 5], zero-indices are [4, 6], one-indices are [1, 3] and wildcard-indices are [0, 2, 5].
+        """
+        if type not in ["wildcard", "ts"]:
+            raise ValueError("Invalid type. Expected 'wildcard' or 'ts'.")
+
+        lut = self.look_up_table()
+        annihilation_outputs_lut = (
+            ((lut["Out:"] == "0") & (lut["In:"].str[3] == "1"))
+            .apply(lambda x: "1" if x else "0")
+            .tolist()
+        )
+        generation_outputs = (
+            ((lut["Out:"] == "1") & (lut["In:"].str[3] == "0"))
+            .apply(lambda x: "1" if x else "0")
+            .tolist()
+        )
+
+        annihilation = BooleanNode.from_output_list(annihilation_outputs_lut)
+        generation = BooleanNode.from_output_list(generation_outputs)
+
+        def _get_annigen_wildcard_coverage(
+            annihilation: BooleanNode, generation: BooleanNode
+        ) -> dict:
+            """
+            Helper function for get_anni_gen_coverage().
+            Computes which LUT entries are covered by the wildcard schemata of the annihilation and generation functions.
+
+            """
+            annihilation._check_compute_canalization_variables(prime_implicants=True)
+            generation._check_compute_canalization_variables(prime_implicants=True)
+
+            pia = annihilation._prime_implicants.get("1", [])
+            pig = generation._prime_implicants.get("1", [])
+
+            pia_coverage = {
+                k: v.intersection(pia) for k, v in annihilation.pi_coverage().items()
+            }
+            pig_coverage = {
+                k: v.intersection(pig) for k, v in generation.pi_coverage().items()
+            }
+
+            annigen_coveragev2 = {}
+            for item in [pia_coverage, pig_coverage]:
+                for key, value in item.items():
+                    if key in annigen_coveragev2:
+                        annigen_coveragev2[key].update(value)
+                    else:
+                        annigen_coveragev2[key] = value
+
+            return annigen_coveragev2
+
+        def _get_annigen_ts_coverage(
+            annihilation: BooleanNode, generation: BooleanNode, k: int
+        ) -> dict:
+            """
+            Helper function for get_anni_gen_coverage().
+            Computes which LUT entries are covered by the two-symbol schemata of the annihilation and generation functions.
+            """
+
+            def _normalize_ts_entries(entries):
+                normalized = []
+                local_seen = set()
+                for entry in entries:
+                    if not entry or len(entry) < 2:
+                        continue
+                    schema = entry[0]
+                    permutable = entry[1]
+                    if permutable:
+                        permutable_lists = [list(group) for group in permutable]
+                    else:
+                        permutable_lists = []
+                    same_symbols = entry[2] if len(entry) > 2 else []
+                    if same_symbols:
+                        same_symbol_lists = [list(group) for group in same_symbols]
+                    else:
+                        same_symbol_lists = []
+                    key = (
+                        schema,
+                        tuple(tuple(group) for group in permutable_lists),
+                        tuple(tuple(group) for group in same_symbol_lists),
+                    )
+                    if key in local_seen:
+                        continue
+                    local_seen.add(key)
+                    normalized.append((key, [schema, permutable_lists, same_symbol_lists]))
+                return normalized
+
+            def _filter_ts_coverage(node: BooleanNode) -> dict:
+                node_coverage = node.ts_coverage()
+                outputs = node.outputs
+                filtered = {}
+                for state, entries in node_coverage.items():
+                    if not entries:
+                        continue
+                    if outputs[binstate_to_statenum(state)] != "1":
+                        continue
+                    normalized = _normalize_ts_entries(entries)
+                    if normalized:
+                        filtered[state] = normalized
+                return filtered
+
+            ann_cov = _filter_ts_coverage(annihilation)
+            gen_cov = _filter_ts_coverage(generation)
+
+            ts_coverage = defaultdict(list)
+            seen_entries = defaultdict(set)
+
+            for source in (ann_cov, gen_cov):
+                for state, normalized_entries in source.items():
+                    existing = ts_coverage[state]
+                    seen = seen_entries[state]
+                    for key, value in normalized_entries:
+                        if key in seen:
+                            continue
+                        seen.add(key)
+                        existing.append(value)
+
+            for state in (statenum_to_binstate(i, base=k) for i in range(2**k)):
+                ts_coverage.setdefault(state, [])
+
+            return dict(ts_coverage)
+
+        if type == "wildcard":
+            return _get_annigen_wildcard_coverage(annihilation, generation)
+        elif type == "ts":
+            return _get_annigen_ts_coverage(annihilation, generation, self.k)
+
+    def input_redundancy_anni_gen(self, operator=mean, norm=False):
+        """
+        The redundancy of the annihilation and generation rules of the node.
+        The mean of the number of '#' in the annihilation and generation rules that cover a row in the LUT.
+
+        Args:
+            operator (function) : The operator to use to calculate the redundancy. Default is mean.
+            norm (bool) : If True, normalize the redundancy.
+
+        Returns:
+            (float) : The redundancy of the annihilation and generation rules of the node.
+
+        See Also:
+            :func:`~cana.boolean_node.BooleanNode.get_anni_gen_coverage`
+        """
+        if not hasattr(operator, "__call__"):
+            raise AttributeError(
+                'The operator you selected must be a function. Try "min", "statitics.mean", or "max".'
+            )
+
+        anni_gen_coverage = {}
+        anni_gen_coverage = self.get_anni_gen_coverage()
+        redundancy = [
+            operator([pi.count("#") for pi in anni_gen_coverage[binstate]])
+            if len(anni_gen_coverage[binstate]) > 0
+            else 0
+            for binstate in anni_gen_coverage
+        ]
+
+        valid_binstate_count = len(
+            [
+                binstate
+                for binstate in anni_gen_coverage
+                if len(anni_gen_coverage[binstate]) > 0
+            ]
+        )
+        if valid_binstate_count == 0: # checking for division by zero error
+            return 0 # if there are no rules that cover the LUT entries, then the redundancy is 0.
+
+        annigen_kr = sum(redundancy) / len(
+            [
+                binstate
+                for binstate in anni_gen_coverage
+                if len(anni_gen_coverage[binstate]) > 0
+            ]
+        )
+        if norm:
+            # Normalizes
+            annigen_kr = annigen_kr / self.k
+
+        return annigen_kr
+
+    def effective_connectivity_anni_gen(self, operator=mean, norm=False):
+        """
+        The effective connectivity of the annihilation and generation rules of the node.
+        The Effective Connectiviy is the mean number of input nodes needed to determine the transition of the node. We take the average effective connectivity of the annihilation and generation rules.
+
+        Args:
+            operator (function) : The operator to use to calculate the effective connectivity. Default is mean.
+            norm (bool) : If True, normalize the effective connectivity.
+
+        Returns:
+            (float) : The effective connectivity of the annihilation and generation rules of the node.
+
+        See Also:
+            :func:`get_anni_gen_coverage`, :func:`input_redundancy_anni_gen`, :func:`input_redundancy`, :func:`effective_connectivity`.
+        """
+        anni_gen_k_r = self.input_redundancy_anni_gen(operator=operator, norm=False)
+        anni_gen_k_e = self.k - anni_gen_k_r
+
+        if norm:
+            anni_gen_k_e = anni_gen_k_e / self.k
+
+        return anni_gen_k_e
diff --git a/cana/canalization/boolean_canalization.py b/cana/canalization/boolean_canalization.py
index 3711a0d..11bed26 100644
--- a/cana/canalization/boolean_canalization.py
+++ b/cana/canalization/boolean_canalization.py
@@ -20,6 +20,11 @@
 import schematodes as sc
 
 from ..cutils import binstate_to_density, statenum_to_binstate
+from .cboolean_canalization import (
+    expand_ts_logic_fast as _expand_ts_logic_fast,
+    pi_covers_fast as _pi_covers_fast,
+    ts_covers_fast as _ts_covers_fast,
+)
 
 __author__ = """\n""".join(
     [
@@ -140,23 +145,26 @@ def _adjacent(imp1, imp2):
     return "".join(match)
 
 
-def __pi_covers(implicant, input, symbol=["2", "#", 2]):
+def __pi_covers(implicant, binstate, symbol=["2", "#", 2]):
     """Determines if a minterm is covered by a specific implicant.
 
     Args:
         implicant (string): the implicant.
-        minterm (string): the minterm.
+        binstate (string): the minterm.
 
     Returns:
         x (bool): True if covered else False.
 
     """
-    for i, m in zip(implicant, input):
-        if i in symbol:
-            continue
-        if int(i) != int(m):
-            return False
-    return True
+    # if _pi_covers_fast is not None:
+    return _pi_covers_fast(implicant, binstate)
+
+    # for i, m in zip(implicant, binstate):
+    #     if i in symbol:
+    #         continue
+    #     if int(i) != int(m):
+    #         return False
+    # return True
 
 
 def computes_pi_coverage(k, outputs, prime_implicants):
@@ -279,27 +287,29 @@ def _expand_ts_logic(two_symbols, permut_indexes):
     Returns:
         (list) : a list of :math:`F'` covered by this Two-Symbol.
     """
-    # If receiving a binary string, convert to list of lists
-    if isinstance(two_symbols, str):
-        two_symbols = [list(two_symbols)]
-    # Queue
-    Q = deque()
-    Q.extend(two_symbols)
-    logics = []
-    #
-    while Q:
-        implicant = np.array(Q.pop())
-        for idxs in permut_indexes:
-            # Permutation of all possible combinations of the values that are permutable.
-            for vals in itertools.permutations(implicant[idxs], len(idxs)):
-                # Generate a new schema
-                _implicant = np.copy(implicant)
-                _implicant[idxs] = vals
-                # Insert to list of logics if not already there
-                if _implicant.tolist() not in logics:
-                    logics.append(_implicant.tolist())
-                    Q.append(_implicant.tolist())
-    return logics
+    # if _expand_ts_logic_fast is not None:
+    return _expand_ts_logic_fast(two_symbols, permut_indexes)
+    # # If receiving a binary string, convert to list of lists
+    # if isinstance(two_symbols, str):
+    #     two_symbols = [list(two_symbols)]
+    # # Queue
+    # Q = deque()
+    # Q.extend(two_symbols)
+    # logics = []
+    # #
+    # while Q:
+    #     implicant = np.array(Q.pop())
+    #     for idxs in permut_indexes:
+    #         # Permutation of all possible combinations of the values that are permutable.
+    #         for vals in itertools.permutations(implicant[idxs], len(idxs)):
+    #             # Generate a new schema
+    #             _implicant = np.copy(implicant)
+    #             _implicant[idxs] = vals
+    #             # Insert to list of logics if not already there
+    #             if _implicant.tolist() not in logics:
+    #                 logics.append(_implicant.tolist())
+    #                 Q.append(_implicant.tolist())
+    # return logics
 
 
 def _check_schemata_permutations(schema, perm_groups, verbose=None, verbose_level=None):
@@ -466,33 +476,35 @@ def _ts_covers(two_symbol, permut_indexes, input, verbose=False):
     """
     if verbose:
         print("Evaluating permutation coverage")
-    # No permutation, just plain implicant coverage?
-    if not len(permut_indexes):
-        if __pi_covers(two_symbol, input):
-            return True
-    # There are permutations to generate and check
-    else:
-        # NEW METHOD: Generates the expanded logic of the Two-Symbol Schema
-        for gen_implicant in _expand_ts_logic(two_symbol, permut_indexes):
-            if __pi_covers(gen_implicant, input):
-                return True
-        """
-        # OLD METHOD
-        for idxs in permut_indexes:
-            # Extract the charactes that can be permuted
-            chars = [implicant[idx] for idx in idxs]
-            # Generate all possible permutations of these symbols
-            permut_chars = itertools.permutations(chars, len(idxs))
-            for permut_chars in permut_chars:
-                # Generate a new implicant and substitute the charactes with the permuted ones
-                tmp = list(implicant)
-                for idx,char in zip(idxs,permut_chars):
-                    tmp[idx] = char
-                # The new permuted implicate is covered?
-                if __pi_covers(tmp, input):
-                    return True
-        """
-    return False
+    # if _ts_covers_fast is not None:
+    return _ts_covers_fast(two_symbol, permut_indexes, input)
+    # # No permutation, just plain implicant coverage?
+    # if not len(permut_indexes):
+    #     if __pi_covers(two_symbol, input):
+    #         return True
+    # # There are permutations to generate and check
+    # else:
+    #     # NEW METHOD: Generates the expanded logic of the Two-Symbol Schema
+    #     for gen_implicant in _expand_ts_logic(two_symbol, permut_indexes):
+    #         if __pi_covers(gen_implicant, input):
+    #             return True
+    #     """
+    #     # OLD METHOD
+    #     for idxs in permut_indexes:
+    #         # Extract the charactes that can be permuted
+    #         chars = [implicant[idx] for idx in idxs]
+    #         # Generate all possible permutations of these symbols
+    #         permut_chars = itertools.permutations(chars, len(idxs))
+    #         for permut_chars in permut_chars:
+    #             # Generate a new implicant and substitute the charactes with the permuted ones
+    #             tmp = list(implicant)
+    #             for idx,char in zip(idxs,permut_chars):
+    #                 tmp[idx] = char
+    #             # The new permuted implicate is covered?
+    #             if __pi_covers(tmp, input):
+    #                 return True
+    #     """
+    # return False
 
 
 def computes_ts_coverage(k, outputs, two_symbols):
diff --git a/cana/canalization/cboolean_canalization.c b/cana/canalization/cboolean_canalization.c
index 577e333..cf2cbc4 100644
--- a/cana/canalization/cboolean_canalization.c
+++ b/cana/canalization/cboolean_canalization.c
@@ -1,11 +1,11 @@
-/* Generated by Cython 0.29.34 */
+/* Generated by Cython 3.0.10 */
 
 /* BEGIN: Cython Metadata
 {
     "distutils": {
         "name": "cana.canalization.cboolean_canalization",
         "sources": [
-            "/home/BU/jrozum/Documents/github/rionbr/cana/CANA/cana/canalization/cboolean_canalization.pyx"
+            "/data/siyer/CANA/cana/canalization/cboolean_canalization.pyx"
         ]
     },
     "module_name": "cana.canalization.cboolean_canalization"
@@ -15,20 +15,37 @@ END: Cython Metadata */
 #ifndef PY_SSIZE_T_CLEAN
 #define PY_SSIZE_T_CLEAN
 #endif /* PY_SSIZE_T_CLEAN */
+#if defined(CYTHON_LIMITED_API) && 0
+  #ifndef Py_LIMITED_API
+    #if CYTHON_LIMITED_API+0 > 0x03030000
+      #define Py_LIMITED_API CYTHON_LIMITED_API
+    #else
+      #define Py_LIMITED_API 0x03030000
+    #endif
+  #endif
+#endif
+
 #include "Python.h"
 #ifndef Py_PYTHON_H
     #error Python headers needed to compile C extensions, please install development version of Python.
-#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
-    #error Cython requires Python 2.6+ or Python 3.3+.
+#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+    #error Cython requires Python 2.7+ or Python 3.3+.
+#else
+#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API
+#define __PYX_EXTRA_ABI_MODULE_NAME "limited"
 #else
-#define CYTHON_ABI "0_29_34"
-#define CYTHON_HEX_VERSION 0x001D22F0
-#define CYTHON_FUTURE_DIVISION 0
+#define __PYX_EXTRA_ABI_MODULE_NAME ""
+#endif
+#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+#define CYTHON_HEX_VERSION 0x03000AF0
+#define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
   #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
 #endif
-#if !defined(WIN32) && !defined(MS_WINDOWS)
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
   #ifndef __stdcall
     #define __stdcall
   #endif
@@ -47,9 +64,7 @@ END: Cython Metadata */
 #endif
 #define __PYX_COMMA ,
 #ifndef HAVE_LONG_LONG
-  #if PY_VERSION_HEX >= 0x02070000
-    #define HAVE_LONG_LONG
-  #endif
+  #define HAVE_LONG_LONG
 #endif
 #ifndef PY_LONG_LONG
   #define PY_LONG_LONG LONG_LONG
@@ -57,13 +72,19 @@ END: Cython Metadata */
 #ifndef Py_HUGE_VAL
   #define Py_HUGE_VAL HUGE_VAL
 #endif
-#ifdef PYPY_VERSION
-  #define CYTHON_COMPILING_IN_PYPY 1
-  #define CYTHON_COMPILING_IN_PYSTON 0
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
   #define CYTHON_COMPILING_IN_NOGIL 0
   #undef CYTHON_USE_TYPE_SLOTS
   #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #if PY_VERSION_HEX < 0x03050000
@@ -88,10 +109,19 @@ END: Cython Metadata */
   #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
-  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
   #undef CYTHON_USE_TP_FINALIZE
   #define CYTHON_USE_TP_FINALIZE 0
   #undef CYTHON_USE_DICT_VERSIONS
@@ -101,44 +131,125 @@ END: Cython Metadata */
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PYSTON_VERSION)
-  #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 1
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
-  #ifndef CYTHON_USE_TYPE_SLOTS
-    #define CYTHON_USE_TYPE_SLOTS 1
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3)
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00)
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
   #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_NOGIL 0
+  #undef CYTHON_CLINE_IN_TRACEBACK
+  #define CYTHON_CLINE_IN_TRACEBACK 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #undef CYTHON_USE_ASYNC_SLOTS
   #define CYTHON_USE_ASYNC_SLOTS 0
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
-  #ifndef CYTHON_USE_UNICODE_INTERNALS
-    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
   #endif
-  #undef CYTHON_USE_UNICODE_WRITER
-  #define CYTHON_USE_UNICODE_WRITER 0
   #undef CYTHON_USE_PYLONG_INTERNALS
   #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
-  #ifndef CYTHON_ASSUME_SAFE_MACROS
-    #define CYTHON_ASSUME_SAFE_MACROS 1
-  #endif
-  #ifndef CYTHON_UNPACK_METHODS
-    #define CYTHON_UNPACK_METHODS 1
-  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #undef CYTHON_PEP489_MULTI_PHASE_INIT
   #define CYTHON_PEP489_MULTI_PHASE_INIT 0
-  #undef CYTHON_USE_TP_FINALIZE
-  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 1
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
   #undef CYTHON_USE_DICT_VERSIONS
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
@@ -146,19 +257,28 @@ END: Cython Metadata */
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
   #endif
-#elif defined(PY_NOGIL)
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL)
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 1
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
   #undef CYTHON_USE_PYTYPE_LOOKUP
   #define CYTHON_USE_PYTYPE_LOOKUP 0
   #ifndef CYTHON_USE_ASYNC_SLOTS
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #endif
   #undef CYTHON_USE_PYLIST_INTERNALS
   #define CYTHON_USE_PYLIST_INTERNALS 0
   #ifndef CYTHON_USE_UNICODE_INTERNALS
@@ -166,8 +286,6 @@ END: Cython Metadata */
   #endif
   #undef CYTHON_USE_UNICODE_WRITER
   #define CYTHON_USE_UNICODE_WRITER 0
-  #undef CYTHON_USE_PYLONG_INTERNALS
-  #define CYTHON_USE_PYLONG_INTERNALS 0
   #ifndef CYTHON_AVOID_BORROWED_REFS
     #define CYTHON_AVOID_BORROWED_REFS 0
   #endif
@@ -179,11 +297,22 @@ END: Cython Metadata */
   #endif
   #undef CYTHON_FAST_THREAD_STATE
   #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
   #undef CYTHON_FAST_PYCALL
   #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
   #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
     #define CYTHON_PEP489_MULTI_PHASE_INIT 1
   #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
   #ifndef CYTHON_USE_TP_FINALIZE
     #define CYTHON_USE_TP_FINALIZE 1
   #endif
@@ -191,18 +320,25 @@ END: Cython Metadata */
   #define CYTHON_USE_DICT_VERSIONS 0
   #undef CYTHON_USE_EXC_INFO_STACK
   #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 0
+  #endif
 #else
   #define CYTHON_COMPILING_IN_PYPY 0
-  #define CYTHON_COMPILING_IN_PYSTON 0
   #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
   #define CYTHON_COMPILING_IN_NOGIL 0
   #ifndef CYTHON_USE_TYPE_SLOTS
     #define CYTHON_USE_TYPE_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYTYPE_LOOKUP
-    #define CYTHON_USE_PYTYPE_LOOKUP 0
-  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
     #define CYTHON_USE_PYTYPE_LOOKUP 1
   #endif
   #if PY_MAJOR_VERSION < 3
@@ -211,11 +347,8 @@ END: Cython Metadata */
   #elif !defined(CYTHON_USE_ASYNC_SLOTS)
     #define CYTHON_USE_ASYNC_SLOTS 1
   #endif
-  #if PY_VERSION_HEX < 0x02070000
-    #undef CYTHON_USE_PYLONG_INTERNALS
-    #define CYTHON_USE_PYLONG_INTERNALS 0
-  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
-    #define CYTHON_USE_PYLONG_INTERNALS (PY_VERSION_HEX < 0x030C00A5)
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 1
   #endif
   #ifndef CYTHON_USE_PYLIST_INTERNALS
     #define CYTHON_USE_PYLIST_INTERNALS 1
@@ -238,37 +371,62 @@ END: Cython Metadata */
   #ifndef CYTHON_UNPACK_METHODS
     #define CYTHON_UNPACK_METHODS 1
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
-    #undef CYTHON_FAST_THREAD_STATE
-    #define CYTHON_FAST_THREAD_STATE 0
-  #elif !defined(CYTHON_FAST_THREAD_STATE)
+  #ifndef CYTHON_FAST_THREAD_STATE
     #define CYTHON_FAST_THREAD_STATE 1
   #endif
+  #ifndef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1)
+  #endif
   #ifndef CYTHON_FAST_PYCALL
-    #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000)
+    #define CYTHON_FAST_PYCALL 1
   #endif
-  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
-    #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
   #endif
-  #ifndef CYTHON_USE_TP_FINALIZE
-    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+  #if PY_VERSION_HEX < 0x03050000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
   #endif
-  #ifndef CYTHON_USE_DICT_VERSIONS
-    #define CYTHON_USE_DICT_VERSIONS ((PY_VERSION_HEX >= 0x030600B1) && (PY_VERSION_HEX < 0x030C00A5))
+  #if PY_VERSION_HEX < 0x030400a1
+    #undef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #elif !defined(CYTHON_USE_TP_FINALIZE)
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #if PY_VERSION_HEX < 0x030600B1
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5)
   #endif
-  #if PY_VERSION_HEX >= 0x030B00A4
+  #if PY_VERSION_HEX < 0x030700A3
     #undef CYTHON_USE_EXC_INFO_STACK
     #define CYTHON_USE_EXC_INFO_STACK 0
   #elif !defined(CYTHON_USE_EXC_INFO_STACK)
-    #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+    #define CYTHON_USE_EXC_INFO_STACK 1
   #endif
   #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
     #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
   #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS 1
+  #endif
 #endif
 #if !defined(CYTHON_FAST_PYCCALL)
 #define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
 #endif
+#if !defined(CYTHON_VECTORCALL)
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1)
+#endif
+#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1)
 #if CYTHON_USE_PYLONG_INTERNALS
   #if PY_MAJOR_VERSION < 3
     #include "longintrepr.h"
@@ -297,6 +455,17 @@ END: Cython Metadata */
     #define CYTHON_RESTRICT
   #endif
 #endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
 #ifndef CYTHON_UNUSED
 # if defined(__GNUC__)
 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
@@ -310,13 +479,16 @@ END: Cython Metadata */
 #   define CYTHON_UNUSED
 # endif
 #endif
-#ifndef CYTHON_MAYBE_UNUSED_VAR
+#ifndef CYTHON_UNUSED_VAR
 #  if defined(__cplusplus)
-     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
 #  else
-#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
 #  endif
 #endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
 #ifndef CYTHON_NCP_UNUSED
 # if CYTHON_COMPILING_IN_CPYTHON
 #  define CYTHON_NCP_UNUSED
@@ -324,28 +496,59 @@ END: Cython Metadata */
 #  define CYTHON_NCP_UNUSED CYTHON_UNUSED
 # endif
 #endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
 #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
 #ifdef _MSC_VER
     #ifndef _MSC_STDINT_H_
         #if _MSC_VER < 1300
-           typedef unsigned char     uint8_t;
-           typedef unsigned int      uint32_t;
+            typedef unsigned char     uint8_t;
+            typedef unsigned short    uint16_t;
+            typedef unsigned int      uint32_t;
+        #else
+            typedef unsigned __int8   uint8_t;
+            typedef unsigned __int16  uint16_t;
+            typedef unsigned __int32  uint32_t;
+        #endif
+    #endif
+    #if _MSC_VER < 1300
+        #ifdef _WIN64
+            typedef unsigned long long  __pyx_uintptr_t;
+        #else
+            typedef unsigned int        __pyx_uintptr_t;
+        #endif
+    #else
+        #ifdef _WIN64
+            typedef unsigned __int64    __pyx_uintptr_t;
         #else
-           typedef unsigned __int8   uint8_t;
-           typedef unsigned __int32  uint32_t;
+            typedef unsigned __int32    __pyx_uintptr_t;
         #endif
     #endif
 #else
-   #include <stdint.h>
+    #include <stdint.h>
+    typedef uintptr_t  __pyx_uintptr_t;
 #endif
 #ifndef CYTHON_FALLTHROUGH
-  #if defined(__cplusplus) && __cplusplus >= 201103L
-    #if __has_cpp_attribute(fallthrough)
-      #define CYTHON_FALLTHROUGH [[fallthrough]]
-    #elif __has_cpp_attribute(clang::fallthrough)
-      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
-    #elif __has_cpp_attribute(gnu::fallthrough)
-      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
     #endif
   #endif
   #ifndef CYTHON_FALLTHROUGH
@@ -355,13 +558,26 @@ END: Cython Metadata */
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
-  #if defined(__clang__ ) && defined(__apple_build_version__)
+  #if defined(__clang__) && defined(__apple_build_version__)
     #if __apple_build_version__ < 7000000
       #undef  CYTHON_FALLTHROUGH
       #define CYTHON_FALLTHROUGH
     #endif
   #endif
 #endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
 
 #ifndef CYTHON_INLINE
   #if defined(__clang__)
@@ -377,85 +593,145 @@ END: Cython Metadata */
   #endif
 #endif
 
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-  #define Py_OptimizeFlag 0
-#endif
 #define __PYX_BUILD_PY_SSIZE_T "n"
 #define CYTHON_FORMAT_SSIZE_T "z"
 #if PY_MAJOR_VERSION < 3
   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
-          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
   #define __Pyx_DefaultClassType PyClass_Type
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
   #define __Pyx_DefaultClassType PyType_Type
-#if PY_VERSION_HEX >= 0x030B00A1
-    static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f,
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
                                                     PyObject *code, PyObject *c, PyObject* n, PyObject *v,
                                                     PyObject *fv, PyObject *cell, PyObject* fn,
                                                     PyObject *name, int fline, PyObject *lnos) {
-        PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL;
-        PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL;
-        const char *fn_cstr=NULL;
-        const char *name_cstr=NULL;
-        PyCodeObject* co=NULL;
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030B0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
         PyObject *type, *value, *traceback;
         PyErr_Fetch(&type, &value, &traceback);
-        if (!(kwds=PyDict_New())) goto end;
-        if (!(argcount=PyLong_FromLong(a))) goto end;
-        if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end;
-        if (!(posonlyargcount=PyLong_FromLong(0))) goto end;
-        if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end;
-        if (!(kwonlyargcount=PyLong_FromLong(k))) goto end;
-        if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end;
-        if (!(nlocals=PyLong_FromLong(l))) goto end;
-        if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end;
-        if (!(stacksize=PyLong_FromLong(s))) goto end;
-        if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end;
-        if (!(flags=PyLong_FromLong(f))) goto end;
-        if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end;
-        if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end;
-        if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end;
-        if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end;
-        if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end;
-        if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too;
-        if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here
-        if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too;
-        Py_XDECREF((PyObject*)co);
-        co = (PyCodeObject*)call_result;
-        call_result = NULL;
-        if (0) {
-            cleanup_code_too:
-            Py_XDECREF((PyObject*)co);
-            co = NULL;
-        }
-        end:
-        Py_XDECREF(kwds);
-        Py_XDECREF(argcount);
-        Py_XDECREF(posonlyargcount);
-        Py_XDECREF(kwonlyargcount);
-        Py_XDECREF(nlocals);
-        Py_XDECREF(stacksize);
-        Py_XDECREF(replace);
-        Py_XDECREF(call_result);
-        Py_XDECREF(empty);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
         if (type) {
             PyErr_Restore(type, value, traceback);
         }
-        return co;
+        return result;
     }
+    #ifndef CO_OPTIMIZED
+    #define CO_OPTIMIZED 0x0001
+    #endif
+    #ifndef CO_NEWLOCALS
+    #define CO_NEWLOCALS 0x0002
+    #endif
+    #ifndef CO_VARARGS
+    #define CO_VARARGS 0x0004
+    #endif
+    #ifndef CO_VARKEYWORDS
+    #define CO_VARKEYWORDS 0x0008
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    #define CO_ASYNC_GENERATOR 0x0200
+    #endif
+    #ifndef CO_GENERATOR
+    #define CO_GENERATOR 0x0020
+    #endif
+    #ifndef CO_COROUTINE
+    #define CO_COROUTINE 0x0080
+    #endif
+#elif PY_VERSION_HEX >= 0x030B0000
+  static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f,
+                                                    PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                                    PyObject *fv, PyObject *cell, PyObject* fn,
+                                                    PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0);
+    if (!empty_bytes) return NULL;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes);
+    Py_DECREF(empty_bytes);
+    return result;
+  }
+#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #else
-  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+  #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 #endif
-  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef CO_COROUTINE
+  #define CO_COROUTINE 0x80
+#endif
+#ifndef CO_ASYNC_GENERATOR
+  #define CO_ASYNC_GENERATOR 0x200
 #endif
 #ifndef Py_TPFLAGS_CHECKTYPES
   #define Py_TPFLAGS_CHECKTYPES 0
@@ -469,6 +745,12 @@ END: Cython Metadata */
 #ifndef Py_TPFLAGS_HAVE_FINALIZE
   #define Py_TPFLAGS_HAVE_FINALIZE 0
 #endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
 #ifndef METH_STACKLESS
   #define METH_STACKLESS 0
 #endif
@@ -480,34 +762,89 @@ END: Cython Metadata */
   typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                           Py_ssize_t nargs, PyObject *kwnames);
 #else
-  #define __Pyx_PyCFunctionFast _PyCFunctionFast
-  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#elif CYTHON_BACKPORT_VECTORCALL
+  typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args,
+                                            size_t nargsf, PyObject *kwnames);
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  ((size_t)1 << (8 * sizeof(size_t) - 1))
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_MAJOR_VERSION >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
 #endif
-#if CYTHON_FAST_PYCCALL
-#define __Pyx_PyFastCFunction_Check(func)\
-    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if __PYX_LIMITED_VERSION_HEX < 0x030900B1
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
 #else
-#define __Pyx_PyFastCFunction_Check(func) 0
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
 #endif
 #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
   #define PyObject_Malloc(s)   PyMem_Malloc(s)
   #define PyObject_Free(p)     PyMem_Free(p)
   #define PyObject_Realloc(p)  PyMem_Realloc(p)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
-  #define PyMem_RawMalloc(n)           PyMem_Malloc(n)
-  #define PyMem_RawRealloc(p, n)       PyMem_Realloc(p, n)
-  #define PyMem_RawFree(p)             PyMem_Free(p)
-#endif
-#if CYTHON_COMPILING_IN_PYSTON
-  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
-  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
 #else
   #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
   #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
 #endif
-#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
   #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
 #elif PY_VERSION_HEX >= 0x03060000
   #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
 #elif PY_VERSION_HEX >= 0x03000000
@@ -515,6 +852,22 @@ END: Cython Metadata */
 #else
   #define __Pyx_PyThreadState_Current _PyThreadState_Current
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+#endif
 #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
 #include "pythread.h"
 #define Py_tss_NEEDS_INIT 0
@@ -545,7 +898,29 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   return PyThread_get_key_value(*key);
 }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#if PY_MAJOR_VERSION < 3
+    #if CYTHON_COMPILING_IN_PYPY
+        #if PYPY_VERSION_NUM < 0x07030600
+            #if defined(__cplusplus) && __cplusplus >= 201402L
+                [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]]
+            #elif defined(__GNUC__) || defined(__clang__)
+                __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")))
+            #elif defined(_MSC_VER)
+                __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))
+            #endif
+            static CYTHON_INLINE int PyGILState_Check(void) {
+                return 0;
+            }
+        #else  // PYPY_VERSION_NUM < 0x07030600
+        #endif  // PYPY_VERSION_NUM < 0x07030600
+    #else
+        static CYTHON_INLINE int PyGILState_Check(void) {
+            PyThreadState * tstate = _PyThreadState_Current;
+            return tstate && (tstate == PyGILState_GetThisThreadState());
+        }
+    #endif
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized)
 #define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
 #else
 #define __Pyx_PyDict_NewPresized(n)  PyDict_New()
@@ -557,12 +932,69 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
   #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
-#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  (Py_TYPE(obj)->tp_iternext)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+  #define __Pyx_PyObject_GetIterNextFunc(obj)  PyIter_Next
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v)
+#else
+  #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v)
+#endif
+#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
 #else
-#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
 #endif
-#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GetLength(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
   #define CYTHON_PEP393_ENABLED 1
   #if PY_VERSION_HEX >= 0x030C0000
     #define __Pyx_PyUnicode_READY(op)       (0)
@@ -573,10 +1005,10 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
   #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
-  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
   #if PY_VERSION_HEX >= 0x030C0000
     #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
   #else
@@ -594,11 +1026,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_READY(op)       (0)
   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
-  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
-  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)sizeof(Py_UNICODE))
   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
-  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch)
   #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
 #endif
 #if CYTHON_COMPILING_IN_PYPY
@@ -609,14 +1041,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 #endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
-  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
-  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
-#endif
-#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
-  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500)
+    #undef PyUnicode_Contains
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
 #endif
 #define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
@@ -645,8 +1083,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 #endif
+#if CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
 #ifndef PySet_CheckExact
-  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
 #endif
 #if PY_VERSION_HEX >= 0x030900A4
   #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
@@ -656,15 +1100,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
 #endif
 #if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
   #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
 #else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
   #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyIntObject                  PyLongObject
   #define PyInt_Type                   PyLong_Type
   #define PyInt_Check(op)              PyLong_Check(op)
   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define __Pyx_Py3Int_Check(op)       PyLong_Check(op)
+  #define __Pyx_Py3Int_CheckExact(op)  PyLong_CheckExact(op)
   #define PyInt_FromString             PyLong_FromString
   #define PyInt_FromUnicode            PyLong_FromUnicode
   #define PyInt_FromLong               PyLong_FromLong
@@ -676,6 +1147,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
   #define PyNumber_Int                 PyNumber_Long
+#else
+  #define __Pyx_Py3Int_Check(op)       (PyLong_Check(op) || PyInt_Check(op))
+  #define __Pyx_Py3Int_CheckExact(op)  (PyLong_CheckExact(op) || PyInt_CheckExact(op))
 #endif
 #if PY_MAJOR_VERSION >= 3
   #define PyBoolObject                 PyLongObject
@@ -693,11 +1167,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
   #define __Pyx_PyInt_AsHash_t   __Pyx_PyIndex_AsSsize_t
 #endif
-#if PY_MAJOR_VERSION >= 3
-  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func))
-#else
-  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
-#endif
 #if CYTHON_USE_ASYNC_SLOTS
   #if PY_VERSION_HEX >= 0x030500B1
     #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
@@ -738,11 +1207,20 @@ static CYTHON_INLINE float __PYX_NAN() {
 #endif
 
 #define __PYX_MARK_ERR_POS(f_index, lineno) \
-    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; }
+    { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__;  (void)__pyx_clineno; }
 #define __PYX_ERR(f_index, lineno, Ln_error) \
     { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
 
-#ifndef __PYX_EXTERN_C
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
   #ifdef __cplusplus
     #define __PYX_EXTERN_C extern "C"
   #else
@@ -801,9 +1279,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
 #else
     #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
 #endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
 static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
-#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
 #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
 #define __Pyx_PyBytes_FromString        PyBytes_FromString
 #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
@@ -821,9 +1300,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
 #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
-#define __Pyx_PyObject_AsWritableString(s)    ((char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
-#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
 #define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
@@ -831,13 +1310,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
 #define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
 #define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
 #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
-static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
-    const Py_UNICODE *u_end = u;
-    while (*u_end++) ;
-    return (size_t)(u_end - u - 1);
-}
-#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
-#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
 #define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
 #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
 #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
@@ -861,8 +1334,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
 #else
 #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
 #endif
-#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
 #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
 static int __Pyx_sys_getdefaultencoding_not_ascii;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -883,7 +1402,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
         char ascii_chars[128];
         int c;
         for (c = 0; c < 128; c++) {
-            ascii_chars[c] = c;
+            ascii_chars[c] = (char) c;
         }
         __Pyx_sys_getdefaultencoding_not_ascii = 1;
         ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
@@ -913,6 +1432,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #else
 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
 #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
 static char* __PYX_DEFAULT_STRING_ENCODING;
 static int __Pyx_init_sys_getdefaultencoding_params(void) {
     PyObject* sys;
@@ -948,87 +1468,64 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) {
 #endif /* __GNUC__ */
 static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
 
+#if !CYTHON_USE_MODULE_STATE
 static PyObject *__pyx_m = NULL;
-static PyObject *__pyx_d;
-static PyObject *__pyx_b;
-static PyObject *__pyx_cython_runtime = NULL;
-static PyObject *__pyx_empty_tuple;
-static PyObject *__pyx_empty_bytes;
-static PyObject *__pyx_empty_unicode;
+#endif
 static int __pyx_lineno;
 static int __pyx_clineno = 0;
-static const char * __pyx_cfilenm= __FILE__;
+static const char * __pyx_cfilenm = __FILE__;
 static const char *__pyx_filename;
 
+/* #### Code section: filename_table ### */
 
 static const char *__pyx_f[] = {
-  "cboolean_canalization.pyx",
+  "cana/canalization/cboolean_canalization.pyx",
 };
+/* #### Code section: utility_code_proto_before_types ### */
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
 
 /*--- Type declarations ---*/
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers;
+struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage;
 struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr;
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage;
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr;
-
-/* "cana/canalization/cboolean_canalization.pyx":137
- * 
- * 
- * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
- */
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers {
-  PyObject_HEAD
-  PyObject *__pyx_v_implicant;
-};
-
-
-/* "cana/canalization/cboolean_canalization.pyx":146
- * 
- *     """
- *     return all(i == WILDCARD_SYMBOL or m == i for i, m in zip(implicant, input))             # <<<<<<<<<<<<<<
- * 
- * 
- */
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr {
-  PyObject_HEAD
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *__pyx_outer_scope;
-  PyObject *__pyx_v_i;
-  PyObject *__pyx_v_m;
-};
 
-
-/* "cana/canalization/cboolean_canalization.pyx":201
+/* "cana/canalization/cboolean_canalization.pyx":367
  * 
  * 
  * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
  *     """Computes the binary states coverage by Prime Implicant schematas.
  * 
  */
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage {
+struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage {
   PyObject_HEAD
   Py_ssize_t __pyx_v_i;
-  PyObject *__pyx_v_piset;
 };
 
 
-/* "cana/canalization/cboolean_canalization.pyx":217
+/* "cana/canalization/cboolean_canalization.pyx":383
  *     for binstate, piset in pi_coverage.items():
  *         for i in range(k):
  *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)             # <<<<<<<<<<<<<<
  * 
  *     return input_to_wildcards
  */
-struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr {
+struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr {
   PyObject_HEAD
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *__pyx_outer_scope;
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *__pyx_outer_scope;
+  PyObject *__pyx_genexpr_arg_0;
   PyObject *__pyx_v_pi;
   PyObject *__pyx_t_0;
   Py_ssize_t __pyx_t_1;
   PyObject *(*__pyx_t_2)(PyObject *);
 };
 
+/* #### Code section: utility_code_proto ### */
 
 /* --- Runtime support code (head) --- */
 /* Refnanny.proto */
@@ -1037,11 +1534,11 @@ struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct
 #endif
 #if CYTHON_REFNANNY
   typedef struct {
-    void (*INCREF)(void*, PyObject*, int);
-    void (*DECREF)(void*, PyObject*, int);
-    void (*GOTREF)(void*, PyObject*, int);
-    void (*GIVEREF)(void*, PyObject*, int);
-    void* (*SetupContext)(const char*, int, const char*);
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
     void (*FinishContext)(void**);
   } __Pyx_RefNannyAPIStruct;
   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
@@ -1051,28 +1548,40 @@ struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
           if (acquire_gil) {\
               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
               PyGILState_Release(__pyx_gilstate_save);\
           } else {\
-              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
           }
 #else
   #define __Pyx_RefNannySetupContext(name, acquire_gil)\
-          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__))
+  #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext()
 #endif
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
   #define __Pyx_RefNannyFinishContext()\
           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
-  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
-  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
-  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
-  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
-  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
 #else
   #define __Pyx_RefNannyDeclarations
   #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
   #define __Pyx_RefNannyFinishContext()
   #define __Pyx_INCREF(r) Py_INCREF(r)
   #define __Pyx_DECREF(r) Py_DECREF(r)
@@ -1083,6 +1592,10 @@ struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct
   #define __Pyx_XGOTREF(r)
   #define __Pyx_XGIVEREF(r)
 #endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
 #define __Pyx_XDECREF_SET(r, v) do {\
         PyObject *tmp = (PyObject *) r;\
         r = v; __Pyx_XDECREF(tmp);\
@@ -1094,6 +1607,57 @@ struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct
 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
 /* PyObjectGetAttrStr.proto */
 #if CYTHON_USE_TYPE_SLOTS
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
@@ -1101,9 +1665,89 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
 #endif
 
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
 /* GetBuiltinName.proto */
 static PyObject *__Pyx_GetBuiltinName(PyObject *name);
 
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i)
+#else
+    #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg)
+    #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg)
+#else
+    #define __Pyx_Arg_NewRef_VARARGS(arg) arg
+    #define __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_Arg_FASTCALL(args, i) args[i]
+    #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) arg  /* no-op, __Pyx_Arg_FASTCALL is direct and this needs
+                                                   to have the same reference counting */
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg)
+#else
+    #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+    #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg)
+    #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start)
+#else
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,
+    const char* function_name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
 /* PyDictVersioning.proto */
 #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
 #define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
@@ -1151,42 +1795,39 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve
 static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
 #endif
 
-/* PyCFunctionFastCall.proto */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
-#else
-#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
-#endif
-
 /* PyFunctionFastCall.proto */
 #if CYTHON_FAST_PYCALL
+#if !CYTHON_VECTORCALL
 #define __Pyx_PyFunction_FastCall(func, args, nargs)\
     __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
-#if 1 || PY_VERSION_HEX < 0x030600B1
 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs);
-#else
-#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
 #endif
 #define __Pyx_BUILD_ASSERT_EXPR(cond)\
     (sizeof(char [1 - 2*!(cond)]) - 1)
 #ifndef Py_MEMBER_SIZE
 #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
 #endif
-#if CYTHON_FAST_PYCALL
-  static size_t __pyx_pyframe_localsplus_offset = 0;
+#if !CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+  #define __Pxy_PyFrame_Initialize_Offsets()
+  #define __Pyx_PyFrame_GetLocalsplus(frame)  ((frame)->f_localsplus)
+#else
+  static size_t __pyx_pyframe_localsplus_offset = 0;
+  #include "frameobject.h"
   #define __Pxy_PyFrame_Initialize_Offsets()\
     ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
      (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
   #define __Pyx_PyFrame_GetLocalsplus(frame)\
     (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
-#endif // CYTHON_FAST_PYCALL
+#endif
+#endif
 #endif
 
 /* PyObjectCall.proto */
@@ -1196,16 +1837,14 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
 #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
 #endif
 
-/* PyObjectCall2Args.proto */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
-
 /* PyObjectCallMethO.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
 #endif
 
-/* PyObjectCallOneArg.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs);
 
 /* PyDictContains.proto */
 static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) {
@@ -1224,36 +1863,6 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
 #define __Pyx_PyObject_Dict_GetItem(obj, name)  PyObject_GetItem(obj, name)
 #endif
 
-/* RaiseArgTupleInvalid.proto */
-static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
-    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
-
-/* RaiseDoubleKeywords.proto */
-static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
-
-/* ParseKeywords.proto */
-static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
-    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
-    const char* function_name);
-
-/* StringJoin.proto */
-#if PY_MAJOR_VERSION < 3
-#define __Pyx_PyString_Join __Pyx_PyBytes_Join
-#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v))
-#else
-#define __Pyx_PyString_Join PyUnicode_Join
-#define __Pyx_PyBaseString_Join PyUnicode_Join
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
-    #if PY_MAJOR_VERSION < 3
-    #define __Pyx_PyBytes_Join _PyString_Join
-    #else
-    #define __Pyx_PyBytes_Join _PyBytes_Join
-    #endif
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values);
-#endif
-
 /* RaiseTooManyValuesToUnpack.proto */
 static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
 
@@ -1273,7 +1882,11 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len)) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
+        #endif
         __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
@@ -1325,49 +1938,32 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                      int is_list, int wraparound, int boundscheck);
 
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
 /* ObjectGetItem.proto */
 #if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key);
 #else
 #define __Pyx_PyObject_GetItem(obj, key)  PyObject_GetItem(obj, key)
 #endif
 
-/* IncludeStringH.proto */
-#include <string.h>
-
-/* BytesEquals.proto */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* UnicodeEquals.proto */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
-
-/* StrEquals.proto */
-#if PY_MAJOR_VERSION >= 3
-#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
-#else
-#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
-#endif
-
-/* PyObjectCallNoArg.proto */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
-#else
-#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
-#endif
-
-/* None.proto */
+/* RaiseUnboundLocalError.proto */
 static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
 
-/* None.proto */
-static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname);
-
 /* PyIntCompare.proto */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace);
+static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace);
 
-/* PyNumberPow2.proto */
-#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1)
-#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0)
-static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace);
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* GetItemIntUnicode.proto */
+#define __Pyx_GetItemInt_Unicode(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Unicode_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "string index out of range"), (Py_UCS4)-1))
+static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i,
+                                                           int wraparound, int boundscheck);
 
 /* ListAppend.proto */
 #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
@@ -1376,7 +1972,11 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
     Py_ssize_t len = Py_SIZE(list);
     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
         Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        L->ob_item[len] = x;
+        #else
         PyList_SET_ITEM(list, len, x);
+        #endif
         __Pyx_SET_SIZE(list, len + 1);
         return 0;
     }
@@ -1386,46 +1986,143 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
 #define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
 #endif
 
-/* PyThreadStateGet.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
-#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
-#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
+/* SliceTupleAndList.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
 #else
-#define __Pyx_PyThreadState_declare
-#define __Pyx_PyThreadState_assign
-#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
+#define __Pyx_PyList_GetSlice(seq, start, stop)   PySequence_GetSlice(seq, start, stop)
+#define __Pyx_PyTuple_GetSlice(seq, start, stop)  PySequence_GetSlice(seq, start, stop)
 #endif
 
-/* PyErrFetchRestore.proto */
-#if CYTHON_FAST_THREAD_STATE
-#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+/* pyfrozenset_new.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it);
+
+/* PySetContains.proto */
+static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq);
+
+/* SetItemInt.proto */
+#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
+               __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
+                                               int is_list, int wraparound, int boundscheck);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectGetMethod.proto */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* pop.proto */
+static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L);
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L);
+#define __Pyx_PyObject_Pop(L) (likely(PyList_CheckExact(L)) ?\
+    __Pyx_PyList_Pop(L) : __Pyx__PyObject_Pop(L))
+#else
+#define __Pyx_PyList_Pop(L)  __Pyx__PyObject_Pop(L)
+#define __Pyx_PyObject_Pop(L)  __Pyx__PyObject_Pop(L)
+#endif
+
+/* UnpackUnboundCMethod.proto */
+typedef struct {
+    PyObject *type;
+    PyObject **method_name;
+    PyCFunction func;
+    PyObject *method;
+    int flag;
+} __Pyx_CachedCFunction;
+
+/* CallUnboundCMethod0.proto */
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
 #if CYTHON_COMPILING_IN_CPYTHON
-#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#define __Pyx_CallUnboundCMethod0(cfunc, self)\
+    (likely((cfunc)->func) ?\
+        (likely((cfunc)->flag == METH_NOARGS) ?  (*((cfunc)->func))(self, NULL) :\
+         (PY_VERSION_HEX >= 0x030600B1 && likely((cfunc)->flag == METH_FASTCALL) ?\
+            (PY_VERSION_HEX >= 0x030700A0 ?\
+                (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0) :\
+                (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL)) :\
+          (PY_VERSION_HEX >= 0x030700A0 && (cfunc)->flag == (METH_FASTCALL | METH_KEYWORDS) ?\
+            (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, &__pyx_empty_tuple, 0, NULL) :\
+            (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ?  ((*(PyCFunctionWithKeywords)(void*)(PyCFunction)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\
+               ((cfunc)->flag == METH_VARARGS ?  (*((cfunc)->func))(self, __pyx_empty_tuple) :\
+               __Pyx__CallUnboundCMethod0(cfunc, self)))))) :\
+        __Pyx__CallUnboundCMethod0(cfunc, self))
 #else
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_CallUnboundCMethod0(cfunc, self)  __Pyx__CallUnboundCMethod0(cfunc, self)
 #endif
+
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
+/* PyNumberPow2.proto */
+#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1)
+#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0)
+static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace);
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
 #else
-#define __Pyx_PyErr_Clear() PyErr_Clear()
-#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
-#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
-#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
-#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
 #endif
 
+/* pep479.proto */
+static void __Pyx_Generator_Replace_StopIteration(int in_async_gen);
+
 /* IterNext.proto */
 #define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL)
 static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *);
 
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* UnpackTupleError.proto */
+static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
+
+/* UnpackTuple2.proto */
+#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\
+    (likely(is_tuple || PyTuple_Check(tuple)) ?\
+        (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\
+            __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\
+            (__Pyx_UnpackTupleError(tuple, 2), -1)) :\
+        __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple))
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
+static int __Pyx_unpack_tuple2_generic(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple);
+
+/* dict_iter.proto */
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_is_dict);
+static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
+                                              PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* FixUpExtensionType.proto */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+#endif
+
+/* ValidateBasesTuple.proto */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases);
+#endif
+
+/* PyType_Ready.proto */
+CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t);
+
 /* PyObject_GenericGetAttrNoDict.proto */
 #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name);
@@ -1436,6 +2133,146 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj
 /* Import.proto */
 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
 
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+#else
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases);
+#endif
+
+/* PyMethodNew.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *typesModule=NULL, *methodType=NULL, *result=NULL;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    typesModule = PyImport_ImportModule("types");
+    if (!typesModule) return NULL;
+    methodType = PyObject_GetAttrString(typesModule, "MethodType");
+    Py_DECREF(typesModule);
+    if (!methodType) return NULL;
+    result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL);
+    Py_DECREF(methodType);
+    return result;
+}
+#elif PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#else
+    #define __Pyx_PyMethod_New PyMethod_New
+#endif
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_BACKPORT_VECTORCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+    PyObject *func_dict;
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    void *defaults;
+    int defaults_pyobjects;
+    size_t defaults_size;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc);
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+                                                         size_t size,
+                                                         int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_BACKPORT_VECTORCALL
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
 /* CLineInTraceback.proto */
 #ifdef CYTHON_CLINE_IN_TRACEBACK
 #define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
@@ -1444,6 +2281,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
 #endif
 
 /* CodeObjectCache.proto */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 typedef struct {
     PyCodeObject* code_object;
     int code_line;
@@ -1457,13 +2295,27 @@ static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 static PyCodeObject *__pyx_find_code_object(int code_line);
 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+#endif
 
 /* AddTraceback.proto */
 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename);
 
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp);
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#else
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
 /* GCCDiagnostics.proto */
-#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 #define __Pyx_HAS_GCC_DIAGNOSTIC
 #endif
 
@@ -1479,24 +2331,22 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
 /* FastTypeChecks.proto */
 #if CYTHON_COMPILING_IN_CPYTHON
 #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
 static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
 static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
 #else
 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
 #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
 #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
 #endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
 
-/* FetchCommonType.proto */
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
-
-/* RaiseException.proto */
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
-
 /* GetTopmostException.proto */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
 #endif
 
@@ -1519,14 +2369,15 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
 static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
 #endif
 
-/* PyObjectGetMethod.proto */
-static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+/* PyObjectCall2Args.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
 
 /* PyObjectCallMethod1.proto */
 static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
 
 /* CoroutineBase.proto */
-typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *);
+struct __pyx_CoroutineObject;
+typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *);
 #if CYTHON_USE_EXC_INFO_STACK
 #define __Pyx_ExcInfoStruct  _PyErr_StackItem
 #else
@@ -1536,7 +2387,7 @@ typedef struct {
     PyObject *exc_traceback;
 } __Pyx_ExcInfoStruct;
 #endif
-typedef struct {
+typedef struct __pyx_CoroutineObject {
     PyObject_HEAD
     __pyx_coroutine_body_t body;
     PyObject *closure;
@@ -1594,54 +2445,68 @@ static int __Pyx_patch_abc(void);
 
 /* Generator.proto */
 #define __Pyx_Generator_USED
-static PyTypeObject *__pyx_GeneratorType = 0;
-#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType)
+#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_GeneratorType)
 #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\
     __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name)
 static PyObject *__Pyx_Generator_Next(PyObject *self);
-static int __pyx_Generator_init(void);
+static int __pyx_Generator_init(PyObject *module);
 
 /* CStringEquals.proto */
 static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *);
 
 /* CheckBinaryVersion.proto */
-static int __Pyx_check_binary_version(void);
+static unsigned long __Pyx_get_runtime_version(void);
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
 
 /* InitStrings.proto */
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
 
-
-/* Module declarations from 'cana.canalization.cboolean_canalization' */
-static PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers = 0;
-static PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = 0;
-static PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage = 0;
-static PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr = 0;
+/* #### Code section: module_declarations ### */
+
+/* Module declarations from "cython" */
+
+/* Module declarations from "cana.canalization.cboolean_canalization" */
+static CYTHON_INLINE int __pyx_f_4cana_12canalization_21cboolean_canalization__is_wildcard_symbol(PyObject *); /*proto*/
+static int __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(PyObject *, PyObject *, int __pyx_skip_dispatch); /*proto*/
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization__normalize_index_groups(PyObject *); /*proto*/
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization__init_implicant_stack(PyObject *); /*proto*/
+static void __pyx_f_4cana_12canalization_21cboolean_canalization__permute_assign(PyObject *, PyObject *, PyObject *, Py_ssize_t, Py_ssize_t, PyObject *, PyObject *); /*proto*/
+static void __pyx_f_4cana_12canalization_21cboolean_canalization__enqueue_permutations(PyObject *, PyObject *, PyObject *, PyObject *); /*proto*/
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization_expand_ts_logic_fast(PyObject *, PyObject *, int __pyx_skip_dispatch); /*proto*/
+static int __pyx_f_4cana_12canalization_21cboolean_canalization_ts_covers_fast(PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
 #define __Pyx_MODULE_NAME "cana.canalization.cboolean_canalization"
 extern int __pyx_module_is_main_cana__canalization__cboolean_canalization;
 int __pyx_module_is_main_cana__canalization__cboolean_canalization = 0;
 
-/* Implementation of 'cana.canalization.cboolean_canalization' */
+/* Implementation of "cana.canalization.cboolean_canalization" */
+/* #### Code section: global_var ### */
 static PyObject *__pyx_builtin_zip;
 static PyObject *__pyx_builtin_enumerate;
-static PyObject *__pyx_builtin_input;
+static PyObject *__pyx_builtin_ValueError;
 static PyObject *__pyx_builtin_range;
+/* #### Code section: string_decls ### */
 static const char __pyx_k_[] = "";
 static const char __pyx_k_0[] = "0";
 static const char __pyx_k_1[] = "1";
+static const char __pyx_k_2[] = "2";
 static const char __pyx_k_b[] = "b";
 static const char __pyx_k_i[] = "i";
 static const char __pyx_k_k[] = "k";
-static const char __pyx_k__2[] = "*";
-static const char __pyx_k__3[] = "#";
+static const char __pyx_k__3[] = "*";
+static const char __pyx_k__4[] = "#";
 static const char __pyx_k_b0[] = "b0";
 static const char __pyx_k_b1[] = "b1";
+static const char __pyx_k_gc[] = "gc";
 static const char __pyx_k_pi[] = "pi";
+static const char __pyx_k__29[] = "?";
 static const char __pyx_k_add[] = "add";
 static const char __pyx_k_idx[] = "idx";
+static const char __pyx_k_pop[] = "pop";
 static const char __pyx_k_zip[] = "zip";
 static const char __pyx_k_args[] = "args";
 static const char __pyx_k_done[] = "done";
-static const char __pyx_k_join[] = "join";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_name[] = "__name__";
 static const char __pyx_k_send[] = "send";
@@ -1650,15 +2515,16 @@ static const char __pyx_k_used[] = "used";
 static const char __pyx_k_wnum[] = "wnum";
 static const char __pyx_k_close[] = "close";
 static const char __pyx_k_count[] = "count";
-static const char __pyx_k_input[] = "input";
 static const char __pyx_k_items[] = "items";
 static const char __pyx_k_piset[] = "piset";
 static const char __pyx_k_range[] = "range";
 static const char __pyx_k_throw[] = "throw";
+static const char __pyx_k_enable[] = "enable";
 static const char __pyx_k_groups[] = "groups";
 static const char __pyx_k_import[] = "__import__";
 static const char __pyx_k_values[] = "values";
 static const char __pyx_k_density[] = "density";
+static const char __pyx_k_disable[] = "disable";
 static const char __pyx_k_genexpr[] = "genexpr";
 static const char __pyx_k_verbose[] = "verbose";
 static const char __pyx_k_binstate[] = "binstate";
@@ -1669,148 +2535,676 @@ static const char __pyx_k_binstate1[] = "binstate1";
 static const char __pyx_k_binstate2[] = "binstate2";
 static const char __pyx_k_enumerate[] = "enumerate";
 static const char __pyx_k_implicant[] = "implicant";
+static const char __pyx_k_isenabled[] = "isenabled";
 static const char __pyx_k_pi_covers[] = "__pi_covers";
+static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_nwildcards[] = "nwildcards";
+static const char __pyx_k_two_symbol[] = "two_symbol";
 static const char __pyx_k_wildstates[] = "wildstates";
 static const char __pyx_k_cana_cutils[] = "cana.cutils";
 static const char __pyx_k_pi_coverage[] = "pi_coverage";
+static const char __pyx_k_two_symbols[] = "two_symbols";
+static const char __pyx_k_is_coroutine[] = "_is_coroutine";
 static const char __pyx_k_wildstatenum[] = "wildstatenum";
 static const char __pyx_k_binary_states[] = "binary_states";
+static const char __pyx_k_class_getitem[] = "__class_getitem__";
 static const char __pyx_k_binary_density[] = "binary_density";
 static const char __pyx_k_density_groups[] = "density_groups";
 static const char __pyx_k_find_wildcards[] = "find_wildcards";
+static const char __pyx_k_permut_indexes[] = "permut_indexes";
+static const char __pyx_k_pi_covers_fast[] = "pi_covers_fast";
+static const char __pyx_k_ts_covers_fast[] = "ts_covers_fast";
 static const char __pyx_k_WILDCARD_SYMBOL[] = "WILDCARD_SYMBOL";
 static const char __pyx_k_input_binstates[] = "input_binstates";
 static const char __pyx_k_prime_implicants[] = "prime_implicants";
 static const char __pyx_k_replace_wildcard[] = "replace_wildcard";
 static const char __pyx_k_flip_binstate_bit[] = "flip_binstate_bit";
+static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
 static const char __pyx_k_find_implicants_qm[] = "find_implicants_qm";
 static const char __pyx_k_input_to_wildcards[] = "input_to_wildcards";
 static const char __pyx_k_matched_implicants[] = "matched_implicants";
 static const char __pyx_k_return_pi_coverage[] = "return_pi_coverage";
 static const char __pyx_k_make_density_groups[] = "make_density_groups";
+static const char __pyx_k_expand_ts_logic_fast[] = "expand_ts_logic_fast";
 static const char __pyx_k_statenum_to_binstate[] = "statenum_to_binstate";
 static const char __pyx_k_input_wildcard_coverage[] = "input_wildcard_coverage";
 static const char __pyx_k_expand_wildcard_schemata[] = "expand_wildcard_schemata";
-static const char __pyx_k_pi_covers_locals_genexpr[] = "__pi_covers.<locals>.genexpr";
 static const char __pyx_k_SYMMETRIC_WILDCARD_SYMBOL[] = "SYMMETRIC_WILDCARD_SYMBOL";
-static const char __pyx_k_cboolean_canalization_pyx[] = "cboolean_canalization.pyx";
 static const char __pyx_k_Cythonized_Boolean_Canalization[] = "\n(Cythonized) Boolean Canalization\n=====================\n\nFunctions to compute the Quine-McCluskey algorithm in cython for increaed computation speed.\n\n";
+static const char __pyx_k_Implicant_and_binstate_must_have[] = "Implicant and binstate must have the same length";
 static const char __pyx_k_cana_canalization_cboolean_canal[] = "cana.canalization.cboolean_canalization";
 static const char __pyx_k_input_wildcard_coverage_locals_g[] = "input_wildcard_coverage.<locals>.genexpr";
-static PyObject *__pyx_kp_s_;
-static PyObject *__pyx_kp_s_0;
-static PyObject *__pyx_kp_s_1;
-static PyObject *__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL;
-static PyObject *__pyx_n_s_WILDCARD_SYMBOL;
-static PyObject *__pyx_n_s__2;
-static PyObject *__pyx_kp_s__3;
-static PyObject *__pyx_n_s_add;
-static PyObject *__pyx_n_s_args;
-static PyObject *__pyx_n_s_b;
-static PyObject *__pyx_n_s_b0;
-static PyObject *__pyx_n_s_b1;
-static PyObject *__pyx_n_s_binary_density;
-static PyObject *__pyx_n_s_binary_states;
-static PyObject *__pyx_n_s_binstate;
-static PyObject *__pyx_n_s_binstate0;
-static PyObject *__pyx_n_s_binstate1;
-static PyObject *__pyx_n_s_binstate2;
-static PyObject *__pyx_n_s_cana_canalization_cboolean_canal;
-static PyObject *__pyx_n_s_cana_cutils;
-static PyObject *__pyx_kp_s_cboolean_canalization_pyx;
-static PyObject *__pyx_n_s_cline_in_traceback;
-static PyObject *__pyx_n_s_close;
-static PyObject *__pyx_n_s_count;
-static PyObject *__pyx_n_s_density;
-static PyObject *__pyx_n_s_density_groups;
-static PyObject *__pyx_n_s_done;
-static PyObject *__pyx_n_s_enumerate;
-static PyObject *__pyx_n_s_expand_wildcard_schemata;
-static PyObject *__pyx_n_s_find_implicants_qm;
-static PyObject *__pyx_n_s_find_wildcards;
-static PyObject *__pyx_n_s_flip_binstate_bit;
-static PyObject *__pyx_n_s_genexpr;
-static PyObject *__pyx_n_s_groups;
-static PyObject *__pyx_n_s_i;
-static PyObject *__pyx_n_s_idx;
-static PyObject *__pyx_n_s_implicant;
-static PyObject *__pyx_n_s_import;
-static PyObject *__pyx_n_s_input;
-static PyObject *__pyx_n_s_input_binstates;
-static PyObject *__pyx_n_s_input_to_wildcards;
-static PyObject *__pyx_n_s_input_wildcard_coverage;
-static PyObject *__pyx_n_s_input_wildcard_coverage_locals_g;
-static PyObject *__pyx_n_s_items;
-static PyObject *__pyx_n_s_join;
-static PyObject *__pyx_n_s_k;
-static PyObject *__pyx_n_s_main;
-static PyObject *__pyx_n_s_make_density_groups;
-static PyObject *__pyx_n_s_matched_implicants;
-static PyObject *__pyx_n_s_name;
-static PyObject *__pyx_n_s_newstate;
-static PyObject *__pyx_n_s_nwildcards;
-static PyObject *__pyx_n_s_pi;
-static PyObject *__pyx_n_s_pi_coverage;
-static PyObject *__pyx_n_s_pi_covers;
-static PyObject *__pyx_n_s_pi_covers_locals_genexpr;
-static PyObject *__pyx_n_s_piset;
-static PyObject *__pyx_n_s_prime_implicants;
-static PyObject *__pyx_n_s_range;
-static PyObject *__pyx_n_s_replace_wildcard;
-static PyObject *__pyx_n_s_return_pi_coverage;
-static PyObject *__pyx_n_s_schemata;
-static PyObject *__pyx_n_s_send;
-static PyObject *__pyx_n_s_statenum_to_binstate;
-static PyObject *__pyx_n_s_test;
-static PyObject *__pyx_n_s_throw;
-static PyObject *__pyx_n_s_used;
-static PyObject *__pyx_n_s_values;
-static PyObject *__pyx_n_s_verbose;
-static PyObject *__pyx_n_s_wildstatenum;
-static PyObject *__pyx_n_s_wildstates;
-static PyObject *__pyx_n_s_wnum;
-static PyObject *__pyx_n_s_zip;
+static const char __pyx_k_cana_canalization_cboolean_canal_2[] = "cana/canalization/cboolean_canalization.pyx";
+/* #### Code section: decls ### */
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_density_groups(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_input_binstates); /* proto */
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wildcards(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate1, PyObject *__pyx_v_binstate2); /* proto */
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_density(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate); /* proto */
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_wildcard(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate, PyObject *__pyx_v_idx); /* proto */
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_implicants_qm(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_input_binstates, CYTHON_UNUSED PyObject *__pyx_v_verbose); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_11__pi_covers_genexpr(PyObject *__pyx_self); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_10__pi_covers(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, CYTHON_UNUSED PyObject *__pyx_v_binstate); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_wildcard_schemata(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_schemata); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_14return_pi_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(PyObject *__pyx_self); /* proto */
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_16input_wildcard_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage); /* proto */
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_10pi_covers_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, PyObject *__pyx_v_binstate); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_ts_logic_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_two_symbols, PyObject *__pyx_v_permut_indexes); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_14ts_covers_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_two_symbol, PyObject *__pyx_v_permut_indexes, PyObject *__pyx_v_binstate); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_16__pi_covers(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, PyObject *__pyx_v_binstate); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_18expand_wildcard_schemata(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_schemata); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_20return_pi_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_22input_wildcard_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage); /* proto */
+static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
 static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
-static PyObject *__pyx_int_0;
-static PyObject *__pyx_int_1;
-static PyObject *__pyx_int_2;
-static PyObject *__pyx_tuple__4;
-static PyObject *__pyx_tuple__6;
-static PyObject *__pyx_tuple__8;
-static PyObject *__pyx_tuple__10;
-static PyObject *__pyx_tuple__12;
-static PyObject *__pyx_tuple__14;
-static PyObject *__pyx_tuple__16;
-static PyObject *__pyx_tuple__18;
-static PyObject *__pyx_tuple__20;
-static PyObject *__pyx_codeobj__5;
-static PyObject *__pyx_codeobj__7;
-static PyObject *__pyx_codeobj__9;
-static PyObject *__pyx_codeobj__11;
-static PyObject *__pyx_codeobj__13;
-static PyObject *__pyx_codeobj__15;
-static PyObject *__pyx_codeobj__17;
-static PyObject *__pyx_codeobj__19;
-static PyObject *__pyx_codeobj__21;
-/* Late includes */
-
-/* "cana/canalization/cboolean_canalization.pyx":24
+static __Pyx_CachedCFunction __pyx_umethod_PyList_Type_pop = {0, 0, 0, 0, 0};
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  #ifdef __Pyx_CyFunction_USED
+  PyTypeObject *__pyx_CyFunctionType;
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  PyTypeObject *__pyx_FusedFunctionType;
+  #endif
+  #ifdef __Pyx_Generator_USED
+  PyTypeObject *__pyx_GeneratorType;
+  #endif
+  #ifdef __Pyx_IterableCoroutine_USED
+  PyTypeObject *__pyx_IterableCoroutineType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineAwaitType;
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  PyTypeObject *__pyx_CoroutineType;
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  PyObject *__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage;
+  PyObject *__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr;
+  #endif
+  PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage;
+  PyTypeObject *__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr;
+  PyObject *__pyx_kp_u_;
+  PyObject *__pyx_kp_u_0;
+  PyObject *__pyx_kp_u_1;
+  PyObject *__pyx_kp_u_2;
+  PyObject *__pyx_kp_u_Implicant_and_binstate_must_have;
+  PyObject *__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL;
+  PyObject *__pyx_n_s_ValueError;
+  PyObject *__pyx_n_s_WILDCARD_SYMBOL;
+  PyObject *__pyx_n_s__29;
+  PyObject *__pyx_n_s__3;
+  PyObject *__pyx_kp_u__3;
+  PyObject *__pyx_kp_u__4;
+  PyObject *__pyx_n_s_add;
+  PyObject *__pyx_n_s_args;
+  PyObject *__pyx_n_s_asyncio_coroutines;
+  PyObject *__pyx_n_s_b;
+  PyObject *__pyx_n_s_b0;
+  PyObject *__pyx_n_s_b1;
+  PyObject *__pyx_n_s_binary_density;
+  PyObject *__pyx_n_s_binary_states;
+  PyObject *__pyx_n_s_binstate;
+  PyObject *__pyx_n_s_binstate0;
+  PyObject *__pyx_n_s_binstate1;
+  PyObject *__pyx_n_s_binstate2;
+  PyObject *__pyx_n_s_cana_canalization_cboolean_canal;
+  PyObject *__pyx_kp_s_cana_canalization_cboolean_canal_2;
+  PyObject *__pyx_n_s_cana_cutils;
+  PyObject *__pyx_n_s_class_getitem;
+  PyObject *__pyx_n_s_cline_in_traceback;
+  PyObject *__pyx_n_s_close;
+  PyObject *__pyx_n_s_count;
+  PyObject *__pyx_n_s_density;
+  PyObject *__pyx_n_s_density_groups;
+  PyObject *__pyx_kp_u_disable;
+  PyObject *__pyx_n_s_done;
+  PyObject *__pyx_kp_u_enable;
+  PyObject *__pyx_n_s_enumerate;
+  PyObject *__pyx_n_s_expand_ts_logic_fast;
+  PyObject *__pyx_n_s_expand_wildcard_schemata;
+  PyObject *__pyx_n_s_find_implicants_qm;
+  PyObject *__pyx_n_s_find_wildcards;
+  PyObject *__pyx_n_s_flip_binstate_bit;
+  PyObject *__pyx_kp_u_gc;
+  PyObject *__pyx_n_s_genexpr;
+  PyObject *__pyx_n_s_groups;
+  PyObject *__pyx_n_s_i;
+  PyObject *__pyx_n_s_idx;
+  PyObject *__pyx_n_s_implicant;
+  PyObject *__pyx_n_s_import;
+  PyObject *__pyx_n_s_input_binstates;
+  PyObject *__pyx_n_s_input_to_wildcards;
+  PyObject *__pyx_n_s_input_wildcard_coverage;
+  PyObject *__pyx_n_s_input_wildcard_coverage_locals_g;
+  PyObject *__pyx_n_s_is_coroutine;
+  PyObject *__pyx_kp_u_isenabled;
+  PyObject *__pyx_n_s_items;
+  PyObject *__pyx_n_s_k;
+  PyObject *__pyx_n_s_main;
+  PyObject *__pyx_n_s_make_density_groups;
+  PyObject *__pyx_n_s_matched_implicants;
+  PyObject *__pyx_n_s_name;
+  PyObject *__pyx_n_s_newstate;
+  PyObject *__pyx_n_s_nwildcards;
+  PyObject *__pyx_n_s_permut_indexes;
+  PyObject *__pyx_n_s_pi;
+  PyObject *__pyx_n_s_pi_coverage;
+  PyObject *__pyx_n_s_pi_covers;
+  PyObject *__pyx_n_s_pi_covers_fast;
+  PyObject *__pyx_n_s_piset;
+  PyObject *__pyx_n_s_pop;
+  PyObject *__pyx_n_s_prime_implicants;
+  PyObject *__pyx_n_s_range;
+  PyObject *__pyx_n_s_replace_wildcard;
+  PyObject *__pyx_n_s_return_pi_coverage;
+  PyObject *__pyx_n_s_schemata;
+  PyObject *__pyx_n_s_send;
+  PyObject *__pyx_n_s_statenum_to_binstate;
+  PyObject *__pyx_n_s_test;
+  PyObject *__pyx_n_s_throw;
+  PyObject *__pyx_n_s_ts_covers_fast;
+  PyObject *__pyx_n_s_two_symbol;
+  PyObject *__pyx_n_s_two_symbols;
+  PyObject *__pyx_n_s_used;
+  PyObject *__pyx_n_s_values;
+  PyObject *__pyx_n_s_verbose;
+  PyObject *__pyx_n_s_wildstatenum;
+  PyObject *__pyx_n_s_wildstates;
+  PyObject *__pyx_n_s_wnum;
+  PyObject *__pyx_n_s_zip;
+  PyObject *__pyx_int_0;
+  PyObject *__pyx_int_1;
+  PyObject *__pyx_int_2;
+  PyObject *__pyx_tuple__2;
+  PyObject *__pyx_tuple__5;
+  PyObject *__pyx_tuple__7;
+  PyObject *__pyx_tuple__9;
+  PyObject *__pyx_tuple__11;
+  PyObject *__pyx_tuple__13;
+  PyObject *__pyx_tuple__15;
+  PyObject *__pyx_tuple__16;
+  PyObject *__pyx_tuple__18;
+  PyObject *__pyx_tuple__20;
+  PyObject *__pyx_tuple__23;
+  PyObject *__pyx_tuple__25;
+  PyObject *__pyx_tuple__27;
+  PyObject *__pyx_codeobj__6;
+  PyObject *__pyx_codeobj__8;
+  PyObject *__pyx_codeobj__10;
+  PyObject *__pyx_codeobj__12;
+  PyObject *__pyx_codeobj__14;
+  PyObject *__pyx_codeobj__17;
+  PyObject *__pyx_codeobj__19;
+  PyObject *__pyx_codeobj__21;
+  PyObject *__pyx_codeobj__22;
+  PyObject *__pyx_codeobj__24;
+  PyObject *__pyx_codeobj__26;
+  PyObject *__pyx_codeobj__28;
+} __pyx_mstate;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+  extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o))
+
+#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (PyState_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstate __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_clear(PyObject *m) {
+  __pyx_mstate *clear_module_state = __pyx_mstate(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_CLEAR(clear_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage);
+  Py_CLEAR(clear_module_state->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage);
+  Py_CLEAR(clear_module_state->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr);
+  Py_CLEAR(clear_module_state->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_0);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_1);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_2);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_Implicant_and_binstate_must_have);
+  Py_CLEAR(clear_module_state->__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ValueError);
+  Py_CLEAR(clear_module_state->__pyx_n_s_WILDCARD_SYMBOL);
+  Py_CLEAR(clear_module_state->__pyx_n_s__29);
+  Py_CLEAR(clear_module_state->__pyx_n_s__3);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__3);
+  Py_CLEAR(clear_module_state->__pyx_kp_u__4);
+  Py_CLEAR(clear_module_state->__pyx_n_s_add);
+  Py_CLEAR(clear_module_state->__pyx_n_s_args);
+  Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b0);
+  Py_CLEAR(clear_module_state->__pyx_n_s_b1);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binary_density);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binary_states);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binstate0);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binstate1);
+  Py_CLEAR(clear_module_state->__pyx_n_s_binstate2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cana_canalization_cboolean_canal);
+  Py_CLEAR(clear_module_state->__pyx_kp_s_cana_canalization_cboolean_canal_2);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cana_cutils);
+  Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem);
+  Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
+  Py_CLEAR(clear_module_state->__pyx_n_s_close);
+  Py_CLEAR(clear_module_state->__pyx_n_s_count);
+  Py_CLEAR(clear_module_state->__pyx_n_s_density);
+  Py_CLEAR(clear_module_state->__pyx_n_s_density_groups);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_disable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_done);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_enable);
+  Py_CLEAR(clear_module_state->__pyx_n_s_enumerate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_expand_ts_logic_fast);
+  Py_CLEAR(clear_module_state->__pyx_n_s_expand_wildcard_schemata);
+  Py_CLEAR(clear_module_state->__pyx_n_s_find_implicants_qm);
+  Py_CLEAR(clear_module_state->__pyx_n_s_find_wildcards);
+  Py_CLEAR(clear_module_state->__pyx_n_s_flip_binstate_bit);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_gc);
+  Py_CLEAR(clear_module_state->__pyx_n_s_genexpr);
+  Py_CLEAR(clear_module_state->__pyx_n_s_groups);
+  Py_CLEAR(clear_module_state->__pyx_n_s_i);
+  Py_CLEAR(clear_module_state->__pyx_n_s_idx);
+  Py_CLEAR(clear_module_state->__pyx_n_s_implicant);
+  Py_CLEAR(clear_module_state->__pyx_n_s_import);
+  Py_CLEAR(clear_module_state->__pyx_n_s_input_binstates);
+  Py_CLEAR(clear_module_state->__pyx_n_s_input_to_wildcards);
+  Py_CLEAR(clear_module_state->__pyx_n_s_input_wildcard_coverage);
+  Py_CLEAR(clear_module_state->__pyx_n_s_input_wildcard_coverage_locals_g);
+  Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled);
+  Py_CLEAR(clear_module_state->__pyx_n_s_items);
+  Py_CLEAR(clear_module_state->__pyx_n_s_k);
+  Py_CLEAR(clear_module_state->__pyx_n_s_main);
+  Py_CLEAR(clear_module_state->__pyx_n_s_make_density_groups);
+  Py_CLEAR(clear_module_state->__pyx_n_s_matched_implicants);
+  Py_CLEAR(clear_module_state->__pyx_n_s_name);
+  Py_CLEAR(clear_module_state->__pyx_n_s_newstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_nwildcards);
+  Py_CLEAR(clear_module_state->__pyx_n_s_permut_indexes);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pi);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pi_coverage);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pi_covers);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pi_covers_fast);
+  Py_CLEAR(clear_module_state->__pyx_n_s_piset);
+  Py_CLEAR(clear_module_state->__pyx_n_s_pop);
+  Py_CLEAR(clear_module_state->__pyx_n_s_prime_implicants);
+  Py_CLEAR(clear_module_state->__pyx_n_s_range);
+  Py_CLEAR(clear_module_state->__pyx_n_s_replace_wildcard);
+  Py_CLEAR(clear_module_state->__pyx_n_s_return_pi_coverage);
+  Py_CLEAR(clear_module_state->__pyx_n_s_schemata);
+  Py_CLEAR(clear_module_state->__pyx_n_s_send);
+  Py_CLEAR(clear_module_state->__pyx_n_s_statenum_to_binstate);
+  Py_CLEAR(clear_module_state->__pyx_n_s_test);
+  Py_CLEAR(clear_module_state->__pyx_n_s_throw);
+  Py_CLEAR(clear_module_state->__pyx_n_s_ts_covers_fast);
+  Py_CLEAR(clear_module_state->__pyx_n_s_two_symbol);
+  Py_CLEAR(clear_module_state->__pyx_n_s_two_symbols);
+  Py_CLEAR(clear_module_state->__pyx_n_s_used);
+  Py_CLEAR(clear_module_state->__pyx_n_s_values);
+  Py_CLEAR(clear_module_state->__pyx_n_s_verbose);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wildstatenum);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wildstates);
+  Py_CLEAR(clear_module_state->__pyx_n_s_wnum);
+  Py_CLEAR(clear_module_state->__pyx_n_s_zip);
+  Py_CLEAR(clear_module_state->__pyx_int_0);
+  Py_CLEAR(clear_module_state->__pyx_int_1);
+  Py_CLEAR(clear_module_state->__pyx_int_2);
+  Py_CLEAR(clear_module_state->__pyx_tuple__2);
+  Py_CLEAR(clear_module_state->__pyx_tuple__5);
+  Py_CLEAR(clear_module_state->__pyx_tuple__7);
+  Py_CLEAR(clear_module_state->__pyx_tuple__9);
+  Py_CLEAR(clear_module_state->__pyx_tuple__11);
+  Py_CLEAR(clear_module_state->__pyx_tuple__13);
+  Py_CLEAR(clear_module_state->__pyx_tuple__15);
+  Py_CLEAR(clear_module_state->__pyx_tuple__16);
+  Py_CLEAR(clear_module_state->__pyx_tuple__18);
+  Py_CLEAR(clear_module_state->__pyx_tuple__20);
+  Py_CLEAR(clear_module_state->__pyx_tuple__23);
+  Py_CLEAR(clear_module_state->__pyx_tuple__25);
+  Py_CLEAR(clear_module_state->__pyx_tuple__27);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__6);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__8);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__10);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__12);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__14);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__17);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__19);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__21);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__22);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__24);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__26);
+  Py_CLEAR(clear_module_state->__pyx_codeobj__28);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstate *traverse_module_state = __pyx_mstate(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  Py_VISIT(traverse_module_state->__pyx_empty_tuple);
+  Py_VISIT(traverse_module_state->__pyx_empty_bytes);
+  Py_VISIT(traverse_module_state->__pyx_empty_unicode);
+  #ifdef __Pyx_CyFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  Py_VISIT(traverse_module_state->__pyx_FusedFunctionType);
+  #endif
+  Py_VISIT(traverse_module_state->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage);
+  Py_VISIT(traverse_module_state->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage);
+  Py_VISIT(traverse_module_state->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr);
+  Py_VISIT(traverse_module_state->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_0);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_1);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_2);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_Implicant_and_binstate_must_have);
+  Py_VISIT(traverse_module_state->__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ValueError);
+  Py_VISIT(traverse_module_state->__pyx_n_s_WILDCARD_SYMBOL);
+  Py_VISIT(traverse_module_state->__pyx_n_s__29);
+  Py_VISIT(traverse_module_state->__pyx_n_s__3);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__3);
+  Py_VISIT(traverse_module_state->__pyx_kp_u__4);
+  Py_VISIT(traverse_module_state->__pyx_n_s_add);
+  Py_VISIT(traverse_module_state->__pyx_n_s_args);
+  Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b0);
+  Py_VISIT(traverse_module_state->__pyx_n_s_b1);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binary_density);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binary_states);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binstate0);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binstate1);
+  Py_VISIT(traverse_module_state->__pyx_n_s_binstate2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cana_canalization_cboolean_canal);
+  Py_VISIT(traverse_module_state->__pyx_kp_s_cana_canalization_cboolean_canal_2);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cana_cutils);
+  Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem);
+  Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
+  Py_VISIT(traverse_module_state->__pyx_n_s_close);
+  Py_VISIT(traverse_module_state->__pyx_n_s_count);
+  Py_VISIT(traverse_module_state->__pyx_n_s_density);
+  Py_VISIT(traverse_module_state->__pyx_n_s_density_groups);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_disable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_done);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_enable);
+  Py_VISIT(traverse_module_state->__pyx_n_s_enumerate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_expand_ts_logic_fast);
+  Py_VISIT(traverse_module_state->__pyx_n_s_expand_wildcard_schemata);
+  Py_VISIT(traverse_module_state->__pyx_n_s_find_implicants_qm);
+  Py_VISIT(traverse_module_state->__pyx_n_s_find_wildcards);
+  Py_VISIT(traverse_module_state->__pyx_n_s_flip_binstate_bit);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_gc);
+  Py_VISIT(traverse_module_state->__pyx_n_s_genexpr);
+  Py_VISIT(traverse_module_state->__pyx_n_s_groups);
+  Py_VISIT(traverse_module_state->__pyx_n_s_i);
+  Py_VISIT(traverse_module_state->__pyx_n_s_idx);
+  Py_VISIT(traverse_module_state->__pyx_n_s_implicant);
+  Py_VISIT(traverse_module_state->__pyx_n_s_import);
+  Py_VISIT(traverse_module_state->__pyx_n_s_input_binstates);
+  Py_VISIT(traverse_module_state->__pyx_n_s_input_to_wildcards);
+  Py_VISIT(traverse_module_state->__pyx_n_s_input_wildcard_coverage);
+  Py_VISIT(traverse_module_state->__pyx_n_s_input_wildcard_coverage_locals_g);
+  Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled);
+  Py_VISIT(traverse_module_state->__pyx_n_s_items);
+  Py_VISIT(traverse_module_state->__pyx_n_s_k);
+  Py_VISIT(traverse_module_state->__pyx_n_s_main);
+  Py_VISIT(traverse_module_state->__pyx_n_s_make_density_groups);
+  Py_VISIT(traverse_module_state->__pyx_n_s_matched_implicants);
+  Py_VISIT(traverse_module_state->__pyx_n_s_name);
+  Py_VISIT(traverse_module_state->__pyx_n_s_newstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_nwildcards);
+  Py_VISIT(traverse_module_state->__pyx_n_s_permut_indexes);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pi);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pi_coverage);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pi_covers);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pi_covers_fast);
+  Py_VISIT(traverse_module_state->__pyx_n_s_piset);
+  Py_VISIT(traverse_module_state->__pyx_n_s_pop);
+  Py_VISIT(traverse_module_state->__pyx_n_s_prime_implicants);
+  Py_VISIT(traverse_module_state->__pyx_n_s_range);
+  Py_VISIT(traverse_module_state->__pyx_n_s_replace_wildcard);
+  Py_VISIT(traverse_module_state->__pyx_n_s_return_pi_coverage);
+  Py_VISIT(traverse_module_state->__pyx_n_s_schemata);
+  Py_VISIT(traverse_module_state->__pyx_n_s_send);
+  Py_VISIT(traverse_module_state->__pyx_n_s_statenum_to_binstate);
+  Py_VISIT(traverse_module_state->__pyx_n_s_test);
+  Py_VISIT(traverse_module_state->__pyx_n_s_throw);
+  Py_VISIT(traverse_module_state->__pyx_n_s_ts_covers_fast);
+  Py_VISIT(traverse_module_state->__pyx_n_s_two_symbol);
+  Py_VISIT(traverse_module_state->__pyx_n_s_two_symbols);
+  Py_VISIT(traverse_module_state->__pyx_n_s_used);
+  Py_VISIT(traverse_module_state->__pyx_n_s_values);
+  Py_VISIT(traverse_module_state->__pyx_n_s_verbose);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wildstatenum);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wildstates);
+  Py_VISIT(traverse_module_state->__pyx_n_s_wnum);
+  Py_VISIT(traverse_module_state->__pyx_n_s_zip);
+  Py_VISIT(traverse_module_state->__pyx_int_0);
+  Py_VISIT(traverse_module_state->__pyx_int_1);
+  Py_VISIT(traverse_module_state->__pyx_int_2);
+  Py_VISIT(traverse_module_state->__pyx_tuple__2);
+  Py_VISIT(traverse_module_state->__pyx_tuple__5);
+  Py_VISIT(traverse_module_state->__pyx_tuple__7);
+  Py_VISIT(traverse_module_state->__pyx_tuple__9);
+  Py_VISIT(traverse_module_state->__pyx_tuple__11);
+  Py_VISIT(traverse_module_state->__pyx_tuple__13);
+  Py_VISIT(traverse_module_state->__pyx_tuple__15);
+  Py_VISIT(traverse_module_state->__pyx_tuple__16);
+  Py_VISIT(traverse_module_state->__pyx_tuple__18);
+  Py_VISIT(traverse_module_state->__pyx_tuple__20);
+  Py_VISIT(traverse_module_state->__pyx_tuple__23);
+  Py_VISIT(traverse_module_state->__pyx_tuple__25);
+  Py_VISIT(traverse_module_state->__pyx_tuple__27);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__6);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__8);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__10);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__12);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__14);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__17);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__19);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__21);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__22);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__24);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__26);
+  Py_VISIT(traverse_module_state->__pyx_codeobj__28);
+  return 0;
+}
+#endif
+/* #### Code section: module_state_defines ### */
+#define __pyx_d __pyx_mstate_global->__pyx_d
+#define __pyx_b __pyx_mstate_global->__pyx_b
+#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime
+#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple
+#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes
+#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode
+#ifdef __Pyx_CyFunction_USED
+#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType
+#endif
+#ifdef __Pyx_FusedFunction_USED
+#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType
+#endif
+#ifdef __Pyx_Generator_USED
+#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType
+#endif
+#ifdef __Pyx_IterableCoroutine_USED
+#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType
+#endif
+#ifdef __Pyx_Coroutine_USED
+#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType
+#endif
+#if CYTHON_USE_MODULE_STATE
+#endif
+#if CYTHON_USE_MODULE_STATE
+#define __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage __pyx_mstate_global->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage
+#define __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr
+#endif
+#define __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage __pyx_mstate_global->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage
+#define __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr
+#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_
+#define __pyx_kp_u_0 __pyx_mstate_global->__pyx_kp_u_0
+#define __pyx_kp_u_1 __pyx_mstate_global->__pyx_kp_u_1
+#define __pyx_kp_u_2 __pyx_mstate_global->__pyx_kp_u_2
+#define __pyx_kp_u_Implicant_and_binstate_must_have __pyx_mstate_global->__pyx_kp_u_Implicant_and_binstate_must_have
+#define __pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL __pyx_mstate_global->__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL
+#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError
+#define __pyx_n_s_WILDCARD_SYMBOL __pyx_mstate_global->__pyx_n_s_WILDCARD_SYMBOL
+#define __pyx_n_s__29 __pyx_mstate_global->__pyx_n_s__29
+#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3
+#define __pyx_kp_u__3 __pyx_mstate_global->__pyx_kp_u__3
+#define __pyx_kp_u__4 __pyx_mstate_global->__pyx_kp_u__4
+#define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add
+#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args
+#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines
+#define __pyx_n_s_b __pyx_mstate_global->__pyx_n_s_b
+#define __pyx_n_s_b0 __pyx_mstate_global->__pyx_n_s_b0
+#define __pyx_n_s_b1 __pyx_mstate_global->__pyx_n_s_b1
+#define __pyx_n_s_binary_density __pyx_mstate_global->__pyx_n_s_binary_density
+#define __pyx_n_s_binary_states __pyx_mstate_global->__pyx_n_s_binary_states
+#define __pyx_n_s_binstate __pyx_mstate_global->__pyx_n_s_binstate
+#define __pyx_n_s_binstate0 __pyx_mstate_global->__pyx_n_s_binstate0
+#define __pyx_n_s_binstate1 __pyx_mstate_global->__pyx_n_s_binstate1
+#define __pyx_n_s_binstate2 __pyx_mstate_global->__pyx_n_s_binstate2
+#define __pyx_n_s_cana_canalization_cboolean_canal __pyx_mstate_global->__pyx_n_s_cana_canalization_cboolean_canal
+#define __pyx_kp_s_cana_canalization_cboolean_canal_2 __pyx_mstate_global->__pyx_kp_s_cana_canalization_cboolean_canal_2
+#define __pyx_n_s_cana_cutils __pyx_mstate_global->__pyx_n_s_cana_cutils
+#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem
+#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
+#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close
+#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count
+#define __pyx_n_s_density __pyx_mstate_global->__pyx_n_s_density
+#define __pyx_n_s_density_groups __pyx_mstate_global->__pyx_n_s_density_groups
+#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable
+#define __pyx_n_s_done __pyx_mstate_global->__pyx_n_s_done
+#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable
+#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate
+#define __pyx_n_s_expand_ts_logic_fast __pyx_mstate_global->__pyx_n_s_expand_ts_logic_fast
+#define __pyx_n_s_expand_wildcard_schemata __pyx_mstate_global->__pyx_n_s_expand_wildcard_schemata
+#define __pyx_n_s_find_implicants_qm __pyx_mstate_global->__pyx_n_s_find_implicants_qm
+#define __pyx_n_s_find_wildcards __pyx_mstate_global->__pyx_n_s_find_wildcards
+#define __pyx_n_s_flip_binstate_bit __pyx_mstate_global->__pyx_n_s_flip_binstate_bit
+#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc
+#define __pyx_n_s_genexpr __pyx_mstate_global->__pyx_n_s_genexpr
+#define __pyx_n_s_groups __pyx_mstate_global->__pyx_n_s_groups
+#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i
+#define __pyx_n_s_idx __pyx_mstate_global->__pyx_n_s_idx
+#define __pyx_n_s_implicant __pyx_mstate_global->__pyx_n_s_implicant
+#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import
+#define __pyx_n_s_input_binstates __pyx_mstate_global->__pyx_n_s_input_binstates
+#define __pyx_n_s_input_to_wildcards __pyx_mstate_global->__pyx_n_s_input_to_wildcards
+#define __pyx_n_s_input_wildcard_coverage __pyx_mstate_global->__pyx_n_s_input_wildcard_coverage
+#define __pyx_n_s_input_wildcard_coverage_locals_g __pyx_mstate_global->__pyx_n_s_input_wildcard_coverage_locals_g
+#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine
+#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled
+#define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items
+#define __pyx_n_s_k __pyx_mstate_global->__pyx_n_s_k
+#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main
+#define __pyx_n_s_make_density_groups __pyx_mstate_global->__pyx_n_s_make_density_groups
+#define __pyx_n_s_matched_implicants __pyx_mstate_global->__pyx_n_s_matched_implicants
+#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name
+#define __pyx_n_s_newstate __pyx_mstate_global->__pyx_n_s_newstate
+#define __pyx_n_s_nwildcards __pyx_mstate_global->__pyx_n_s_nwildcards
+#define __pyx_n_s_permut_indexes __pyx_mstate_global->__pyx_n_s_permut_indexes
+#define __pyx_n_s_pi __pyx_mstate_global->__pyx_n_s_pi
+#define __pyx_n_s_pi_coverage __pyx_mstate_global->__pyx_n_s_pi_coverage
+#define __pyx_n_s_pi_covers __pyx_mstate_global->__pyx_n_s_pi_covers
+#define __pyx_n_s_pi_covers_fast __pyx_mstate_global->__pyx_n_s_pi_covers_fast
+#define __pyx_n_s_piset __pyx_mstate_global->__pyx_n_s_piset
+#define __pyx_n_s_pop __pyx_mstate_global->__pyx_n_s_pop
+#define __pyx_n_s_prime_implicants __pyx_mstate_global->__pyx_n_s_prime_implicants
+#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range
+#define __pyx_n_s_replace_wildcard __pyx_mstate_global->__pyx_n_s_replace_wildcard
+#define __pyx_n_s_return_pi_coverage __pyx_mstate_global->__pyx_n_s_return_pi_coverage
+#define __pyx_n_s_schemata __pyx_mstate_global->__pyx_n_s_schemata
+#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send
+#define __pyx_n_s_statenum_to_binstate __pyx_mstate_global->__pyx_n_s_statenum_to_binstate
+#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test
+#define __pyx_n_s_throw __pyx_mstate_global->__pyx_n_s_throw
+#define __pyx_n_s_ts_covers_fast __pyx_mstate_global->__pyx_n_s_ts_covers_fast
+#define __pyx_n_s_two_symbol __pyx_mstate_global->__pyx_n_s_two_symbol
+#define __pyx_n_s_two_symbols __pyx_mstate_global->__pyx_n_s_two_symbols
+#define __pyx_n_s_used __pyx_mstate_global->__pyx_n_s_used
+#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values
+#define __pyx_n_s_verbose __pyx_mstate_global->__pyx_n_s_verbose
+#define __pyx_n_s_wildstatenum __pyx_mstate_global->__pyx_n_s_wildstatenum
+#define __pyx_n_s_wildstates __pyx_mstate_global->__pyx_n_s_wildstates
+#define __pyx_n_s_wnum __pyx_mstate_global->__pyx_n_s_wnum
+#define __pyx_n_s_zip __pyx_mstate_global->__pyx_n_s_zip
+#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0
+#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1
+#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2
+#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2
+#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5
+#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7
+#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9
+#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11
+#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13
+#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15
+#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16
+#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18
+#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20
+#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23
+#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25
+#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27
+#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6
+#define __pyx_codeobj__8 __pyx_mstate_global->__pyx_codeobj__8
+#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10
+#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12
+#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14
+#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17
+#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19
+#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21
+#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22
+#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24
+#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26
+#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28
+/* #### Code section: module_code ### */
+
+/* "cana/canalization/cboolean_canalization.pyx":26
  * # Quine-McCluskey Functions
  * #
  * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
@@ -1819,16 +3213,98 @@ static PyObject *__pyx_codeobj__21;
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups(PyObject *__pyx_self, PyObject *__pyx_v_input_binstates); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_make_density_groups[] = "\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_1make_density_groups = {"make_density_groups", (PyCFunction)__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups, METH_O, __pyx_doc_4cana_12canalization_21cboolean_canalization_make_density_groups};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups(PyObject *__pyx_self, PyObject *__pyx_v_input_binstates) {
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_make_density_groups, "\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_1make_density_groups = {"make_density_groups", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_make_density_groups};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_1make_density_groups(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_input_binstates = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("make_density_groups (wrapper)", 0);
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_make_density_groups(__pyx_self, ((PyObject *)__pyx_v_input_binstates));
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_binstates,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_binstates)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "make_density_groups") < 0)) __PYX_ERR(0, 26, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_input_binstates = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_density_groups", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 26, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.make_density_groups", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_make_density_groups(__pyx_self, __pyx_v_input_binstates);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -1850,21 +3326,21 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("make_density_groups", 0);
+  __Pyx_RefNannySetupContext("make_density_groups", 1);
 
-  /* "cana/canalization/cboolean_canalization.pyx":28
+  /* "cana/canalization/cboolean_canalization.pyx":30
  *     """
  * 
  *     density_groups = dict()             # <<<<<<<<<<<<<<
  *     for binstate in input_binstates:
  *         density = binary_density(binstate)
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_density_groups = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":29
+  /* "cana/canalization/cboolean_canalization.pyx":31
  * 
  *     density_groups = dict()
  *     for binstate in input_binstates:             # <<<<<<<<<<<<<<
@@ -1872,29 +3348,42 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
  *         if density not in density_groups:
  */
   if (likely(PyList_CheckExact(__pyx_v_input_binstates)) || PyTuple_CheckExact(__pyx_v_input_binstates)) {
-    __pyx_t_1 = __pyx_v_input_binstates; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+    __pyx_t_1 = __pyx_v_input_binstates; __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_2 = 0;
     __pyx_t_3 = NULL;
   } else {
-    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_binstates); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_input_binstates); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 31, __pyx_L1_error)
   }
   for (;;) {
     if (likely(!__pyx_t_3)) {
       if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 31, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 29, __pyx_L1_error)
+        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 31, __pyx_L1_error)
         #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         #endif
       } else {
-        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 31, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 29, __pyx_L1_error)
+        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 31, __pyx_L1_error)
         #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error)
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_4);
         #endif
       }
@@ -1904,7 +3393,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 29, __pyx_L1_error)
+          else __PYX_ERR(0, 31, __pyx_L1_error)
         }
         break;
       }
@@ -1913,57 +3402,63 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
     __Pyx_XDECREF_SET(__pyx_v_binstate, __pyx_t_4);
     __pyx_t_4 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":30
+    /* "cana/canalization/cboolean_canalization.pyx":32
  *     density_groups = dict()
  *     for binstate in input_binstates:
  *         density = binary_density(binstate)             # <<<<<<<<<<<<<<
  *         if density not in density_groups:
  *             density_groups[density] = set()
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_binary_density); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 30, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_binary_density); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
     __pyx_t_6 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_7 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
       __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
       if (likely(__pyx_t_6)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
         __Pyx_INCREF(__pyx_t_6);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_7 = 1;
       }
     }
-    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_binstate) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_binstate);
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_binstate};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
     __Pyx_XDECREF_SET(__pyx_v_density, __pyx_t_4);
     __pyx_t_4 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":31
+    /* "cana/canalization/cboolean_canalization.pyx":33
  *     for binstate in input_binstates:
  *         density = binary_density(binstate)
  *         if density not in density_groups:             # <<<<<<<<<<<<<<
  *             density_groups[density] = set()
  *         density_groups[density].add(binstate)
  */
-    __pyx_t_7 = (__Pyx_PyDict_ContainsTF(__pyx_v_density, __pyx_v_density_groups, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 31, __pyx_L1_error)
-    __pyx_t_8 = (__pyx_t_7 != 0);
+    __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_v_density, __pyx_v_density_groups, Py_NE)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 33, __pyx_L1_error)
     if (__pyx_t_8) {
 
-      /* "cana/canalization/cboolean_canalization.pyx":32
+      /* "cana/canalization/cboolean_canalization.pyx":34
  *         density = binary_density(binstate)
  *         if density not in density_groups:
  *             density_groups[density] = set()             # <<<<<<<<<<<<<<
  *         density_groups[density].add(binstate)
  * 
  */
-      __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error)
+      __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      if (unlikely(PyDict_SetItem(__pyx_v_density_groups, __pyx_v_density, __pyx_t_4) < 0)) __PYX_ERR(0, 32, __pyx_L1_error)
+      if (unlikely((PyDict_SetItem(__pyx_v_density_groups, __pyx_v_density, __pyx_t_4) < 0))) __PYX_ERR(0, 34, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":31
+      /* "cana/canalization/cboolean_canalization.pyx":33
  *     for binstate in input_binstates:
  *         density = binary_density(binstate)
  *         if density not in density_groups:             # <<<<<<<<<<<<<<
@@ -1972,36 +3467,43 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
  */
     }
 
-    /* "cana/canalization/cboolean_canalization.pyx":33
+    /* "cana/canalization/cboolean_canalization.pyx":35
  *         if density not in density_groups:
  *             density_groups[density] = set()
  *         density_groups[density].add(binstate)             # <<<<<<<<<<<<<<
  * 
  *     return density_groups
  */
-    __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_density_groups, __pyx_v_density); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_density_groups, __pyx_v_density); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 35, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 33, __pyx_L1_error)
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 35, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_6);
     __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     __pyx_t_5 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (likely(PyMethod_Check(__pyx_t_6))) {
       __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
       if (likely(__pyx_t_5)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
         __Pyx_INCREF(__pyx_t_5);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_6, function);
+        __pyx_t_7 = 1;
       }
     }
-    __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, __pyx_v_binstate) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_binstate);
-    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_binstate};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":29
+    /* "cana/canalization/cboolean_canalization.pyx":31
  * 
  *     density_groups = dict()
  *     for binstate in input_binstates:             # <<<<<<<<<<<<<<
@@ -2011,7 +3513,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":35
+  /* "cana/canalization/cboolean_canalization.pyx":37
  *         density_groups[density].add(binstate)
  * 
  *     return density_groups             # <<<<<<<<<<<<<<
@@ -2023,7 +3525,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
   __pyx_r = __pyx_v_density_groups;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":24
+  /* "cana/canalization/cboolean_canalization.pyx":26
  * # Quine-McCluskey Functions
  * #
  * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
@@ -2048,7 +3550,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":38
+/* "cana/canalization/cboolean_canalization.pyx":40
  * 
  * 
  * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
@@ -2057,60 +3559,100 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_make_dens
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_2find_wildcards[] = "\n    Compare two binary states and replace any differing bits by a wildcard.\n    Args:\n        binstate1, binstate2 : the two binary states to be compared\n\n    Return:\n        c (list, bool) : a list of comparisons\n\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_3find_wildcards = {"find_wildcards", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_2find_wildcards};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_2find_wildcards, "\n    Compare two binary states and replace any differing bits by a wildcard.\n    Args:\n        binstate1, binstate2 : the two binary states to be compared\n\n    Return:\n        c (list, bool) : a list of comparisons\n\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_3find_wildcards = {"find_wildcards", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_2find_wildcards};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wildcards(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_binstate1 = 0;
   PyObject *__pyx_v_binstate2 = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("find_wildcards (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_binstate1,&__pyx_n_s_binstate2,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_binstate1,&__pyx_n_s_binstate2,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_binstate1)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate1)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_binstate2)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate2)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("find_wildcards", 1, 2, 2, 1); __PYX_ERR(0, 38, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("find_wildcards", 1, 2, 2, 1); __PYX_ERR(0, 40, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "find_wildcards") < 0)) __PYX_ERR(0, 38, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "find_wildcards") < 0)) __PYX_ERR(0, 40, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_binstate1 = values[0];
     __pyx_v_binstate2 = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("find_wildcards", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("find_wildcards", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 40, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("cana.canalization.cboolean_canalization.find_wildcards", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2118,13 +3660,19 @@ static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_3find_wil
   __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wildcards(__pyx_self, __pyx_v_binstate1, __pyx_v_binstate2);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
 static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wildcards(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate1, PyObject *__pyx_v_binstate2) {
-  PyObject *__pyx_v_b0 = NULL;
-  PyObject *__pyx_v_b1 = NULL;
+  PyObject *__pyx_7genexpr__pyx_v_b0 = NULL;
+  PyObject *__pyx_7genexpr__pyx_v_b1 = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
@@ -2140,9 +3688,9 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wil
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("find_wildcards", 0);
+  __Pyx_RefNannySetupContext("find_wildcards", 1);
 
-  /* "cana/canalization/cboolean_canalization.pyx":49
+  /* "cana/canalization/cboolean_canalization.pyx":51
  *     """
  *     # assert len(s1) == len(s2) , "The two binstates must have the same length"
  *     return "".join([b0 if (b0 == b1) else WILDCARD_SYMBOL for b0, b1 in zip(binstate1, binstate2)])             # <<<<<<<<<<<<<<
@@ -2150,133 +3698,156 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wil
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_INCREF(__pyx_v_binstate1);
-  __Pyx_GIVEREF(__pyx_v_binstate1);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_binstate1);
-  __Pyx_INCREF(__pyx_v_binstate2);
-  __Pyx_GIVEREF(__pyx_v_binstate2);
-  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_binstate2);
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
-    __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
-    __pyx_t_5 = NULL;
-  } else {
-    __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
+  { /* enter inner scope */
+    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L5_error)
     __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 49, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_5)) {
-      if (likely(PyList_CheckExact(__pyx_t_2))) {
-        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 49, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        #endif
+    __Pyx_INCREF(__pyx_v_binstate1);
+    __Pyx_GIVEREF(__pyx_v_binstate1);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_binstate1)) __PYX_ERR(0, 51, __pyx_L5_error);
+    __Pyx_INCREF(__pyx_v_binstate2);
+    __Pyx_GIVEREF(__pyx_v_binstate2);
+    if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_binstate2)) __PYX_ERR(0, 51, __pyx_L5_error);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L5_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+      __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2);
+      __pyx_t_4 = 0;
+      __pyx_t_5 = NULL;
+    } else {
+      __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L5_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L5_error)
+    }
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_5)) {
+        if (likely(PyList_CheckExact(__pyx_t_2))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 51, __pyx_L5_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 51, __pyx_L5_error)
+          #else
+          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          #endif
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 51, __pyx_L5_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 51, __pyx_L5_error)
+          #else
+          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L5_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          #endif
+        }
       } else {
-        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 49, __pyx_L1_error)
-        #else
-        __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
+        __pyx_t_3 = __pyx_t_5(__pyx_t_2);
+        if (unlikely(!__pyx_t_3)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 51, __pyx_L5_error)
+          }
+          break;
+        }
         __Pyx_GOTREF(__pyx_t_3);
-        #endif
       }
-    } else {
-      __pyx_t_3 = __pyx_t_5(__pyx_t_2);
-      if (unlikely(!__pyx_t_3)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 49, __pyx_L1_error)
+      if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+        PyObject* sequence = __pyx_t_3;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(0, 51, __pyx_L5_error)
         }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_3);
-    }
-    if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
-      PyObject* sequence = __pyx_t_3;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(0, 49, __pyx_L1_error)
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_7 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_7);
+        #else
+        __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 51, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        #endif
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 51, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_8);
+        index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L8_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_6);
+        index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L8_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_7);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 51, __pyx_L5_error)
+        __pyx_t_9 = NULL;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        goto __pyx_L9_unpacking_done;
+        __pyx_L8_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __pyx_t_9 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(0, 51, __pyx_L5_error)
+        __pyx_L9_unpacking_done:;
       }
-      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_b0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_b1, __pyx_t_7);
+      __pyx_t_7 = 0;
+      __pyx_t_7 = PyObject_RichCompare(__pyx_7genexpr__pyx_v_b0, __pyx_7genexpr__pyx_v_b1, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L5_error)
+      __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 51, __pyx_L5_error)
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (__pyx_t_10) {
+        __Pyx_INCREF(__pyx_7genexpr__pyx_v_b0);
+        __pyx_t_3 = __pyx_7genexpr__pyx_v_b0;
       } else {
-        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_7 = PyList_GET_ITEM(sequence, 1); 
+        __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L5_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __pyx_t_3 = __pyx_t_7;
+        __pyx_t_7 = 0;
       }
-      __Pyx_INCREF(__pyx_t_6);
-      __Pyx_INCREF(__pyx_t_7);
-      #else
-      __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 49, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      #endif
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 51, __pyx_L5_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext;
-      index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_6);
-      index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_7);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
-      __pyx_t_9 = NULL;
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      goto __pyx_L6_unpacking_done;
-      __pyx_L5_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-      __pyx_t_9 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(0, 49, __pyx_L1_error)
-      __pyx_L6_unpacking_done:;
-    }
-    __Pyx_XDECREF_SET(__pyx_v_b0, __pyx_t_6);
-    __pyx_t_6 = 0;
-    __Pyx_XDECREF_SET(__pyx_v_b1, __pyx_t_7);
-    __pyx_t_7 = 0;
-    __pyx_t_7 = PyObject_RichCompare(__pyx_v_b0, __pyx_v_b1, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 49, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    if (__pyx_t_10) {
-      __Pyx_INCREF(__pyx_v_b0);
-      __pyx_t_3 = __pyx_v_b0;
-    } else {
-      __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __pyx_t_3 = __pyx_t_7;
-      __pyx_t_7 = 0;
     }
-    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 49, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyString_Join(__pyx_kp_s_, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b0); __pyx_7genexpr__pyx_v_b0 = 0;
+    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b1); __pyx_7genexpr__pyx_v_b1 = 0;
+    goto __pyx_L11_exit_scope;
+    __pyx_L5_error:;
+    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b0); __pyx_7genexpr__pyx_v_b0 = 0;
+    __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b1); __pyx_7genexpr__pyx_v_b1 = 0;
+    goto __pyx_L1_error;
+    __pyx_L11_exit_scope:;
+  } /* exit inner scope */
+  __pyx_t_2 = PyUnicode_Join(__pyx_kp_u_, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_r = __pyx_t_2;
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":38
+  /* "cana/canalization/cboolean_canalization.pyx":40
  * 
  * 
  * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
@@ -2295,14 +3866,14 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wil
   __Pyx_AddTraceback("cana.canalization.cboolean_canalization.find_wildcards", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_b0);
-  __Pyx_XDECREF(__pyx_v_b1);
+  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b0);
+  __Pyx_XDECREF(__pyx_7genexpr__pyx_v_b1);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":52
+/* "cana/canalization/cboolean_canalization.pyx":54
  * 
  * 
  * def binary_density(binstate):             # <<<<<<<<<<<<<<
@@ -2311,61 +3882,151 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_2find_wil
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density(PyObject *__pyx_self, PyObject *__pyx_v_binstate); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_4binary_density[] = "\n    Find the density (number of 1s) for a term with possible wildcards.\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_5binary_density = {"binary_density", (PyCFunction)__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density, METH_O, __pyx_doc_4cana_12canalization_21cboolean_canalization_4binary_density};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density(PyObject *__pyx_self, PyObject *__pyx_v_binstate) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("binary_density (wrapper)", 0);
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_density(__pyx_self, ((PyObject *)__pyx_v_binstate));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_density(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_4binary_density, "\n    Find the density (number of 1s) for a term with possible wildcards.\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_5binary_density = {"binary_density", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_4binary_density};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_5binary_density(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_binstate = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("binary_density", 0);
-
-  /* "cana/canalization/cboolean_canalization.pyx":56
- *     Find the density (number of 1s) for a term with possible wildcards.
- *     """
- *     return binstate.count('1')             # <<<<<<<<<<<<<<
- * 
- * 
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("binary_density (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_binstate,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "binary_density") < 0)) __PYX_ERR(0, 54, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_binstate = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("binary_density", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 54, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.binary_density", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_density(__pyx_self, __pyx_v_binstate);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_density(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_binstate) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("binary_density", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":58
+ *     Find the density (number of 1s) for a term with possible wildcards.
+ *     """
+ *     return binstate.count('1')             # <<<<<<<<<<<<<<
+ * 
+ * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_binstate, __pyx_n_s_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_binstate, __pyx_n_s_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+  __pyx_t_4 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
     __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
     if (likely(__pyx_t_3)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
       __Pyx_INCREF(__pyx_t_3);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_4 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s_1);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_u_1};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":52
+  /* "cana/canalization/cboolean_canalization.pyx":54
  * 
  * 
  * def binary_density(binstate):             # <<<<<<<<<<<<<<
@@ -2386,7 +4047,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_d
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":59
+/* "cana/canalization/cboolean_canalization.pyx":61
  * 
  * 
  * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
@@ -2395,60 +4056,100 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_4binary_d
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_6replace_wildcard[] = "\n    Return the binary state with a wildcard at the idx position.\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_7replace_wildcard = {"replace_wildcard", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_6replace_wildcard};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_6replace_wildcard, "\n    Return the binary state with a wildcard at the idx position.\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_7replace_wildcard = {"replace_wildcard", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_6replace_wildcard};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_wildcard(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_binstate = 0;
   PyObject *__pyx_v_idx = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("replace_wildcard (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_binstate,&__pyx_n_s_idx,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_binstate,&__pyx_n_s_idx,0};
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_binstate)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_idx)) != 0)) kw_args--;
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_idx)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("replace_wildcard", 1, 2, 2, 1); __PYX_ERR(0, 59, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("replace_wildcard", 1, 2, 2, 1); __PYX_ERR(0, 61, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "replace_wildcard") < 0)) __PYX_ERR(0, 59, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "replace_wildcard") < 0)) __PYX_ERR(0, 61, __pyx_L3_error)
       }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+    } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
     } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_binstate = values[0];
     __pyx_v_idx = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("replace_wildcard", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 59, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("replace_wildcard", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 61, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("cana.canalization.cboolean_canalization.replace_wildcard", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2456,6 +4157,12 @@ static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_7replace_
   __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_wildcard(__pyx_self, __pyx_v_binstate, __pyx_v_idx);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2469,9 +4176,9 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("replace_wildcard", 0);
+  __Pyx_RefNannySetupContext("replace_wildcard", 1);
 
-  /* "cana/canalization/cboolean_canalization.pyx":63
+  /* "cana/canalization/cboolean_canalization.pyx":65
  *     Return the binary state with a wildcard at the idx position.
  *     """
  *     return binstate[:idx] + WILDCARD_SYMBOL + binstate[idx + 1:]             # <<<<<<<<<<<<<<
@@ -2479,20 +4186,20 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_binstate, 0, 0, NULL, &__pyx_v_idx, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_binstate, 0, 0, NULL, &__pyx_v_idx, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_idx, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_idx, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_binstate, 0, 0, &__pyx_t_2, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_binstate, 0, 0, &__pyx_t_2, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -2500,7 +4207,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_
   __pyx_t_2 = 0;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":59
+  /* "cana/canalization/cboolean_canalization.pyx":61
  * 
  * 
  * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
@@ -2521,7 +4228,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":66
+/* "cana/canalization/cboolean_canalization.pyx":68
  * 
  * 
  * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
@@ -2530,53 +4237,82 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_6replace_
  */
 
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_8find_implicants_qm[] = " Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.\n\n    Args:\n        input_binstates (list / set) : A the binstates to condense.\n\n    Returns:\n        PI (set): a set of prime implicants.\n\n    # Authors: Alex Gates\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_9find_implicants_qm = {"find_implicants_qm", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_8find_implicants_qm};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_8find_implicants_qm, " Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.\n\n    Args:\n        input_binstates (list / set) : A the binstates to condense.\n\n    Returns:\n        PI (set): a set of prime implicants.\n\n    # Authors: Alex Gates\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_9find_implicants_qm = {"find_implicants_qm", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_8find_implicants_qm};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_implicants_qm(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
   PyObject *__pyx_v_input_binstates = 0;
   CYTHON_UNUSED PyObject *__pyx_v_verbose = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   PyObject *__pyx_r = 0;
   __Pyx_RefNannyDeclarations
   __Pyx_RefNannySetupContext("find_implicants_qm (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
   {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_binstates,&__pyx_n_s_verbose,0};
-    PyObject* values[2] = {0,0};
-    values[1] = ((PyObject *)Py_False);
-    if (unlikely(__pyx_kwds)) {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_input_binstates,&__pyx_n_s_verbose,0};
+    values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)Py_False)));
+    if (__pyx_kwds) {
       Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         CYTHON_FALLTHROUGH;
         case  0: break;
         default: goto __pyx_L5_argtuple_error;
       }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
         case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_binstates)) != 0)) kw_args--;
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_input_binstates)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
         if (kw_args > 0) {
-          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_verbose);
-          if (value) { values[1] = value; kw_args--; }
+          PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_verbose);
+          if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; }
+          else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "find_implicants_qm") < 0)) __PYX_ERR(0, 66, __pyx_L3_error)
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "find_implicants_qm") < 0)) __PYX_ERR(0, 68, __pyx_L3_error)
       }
     } else {
-      switch (PyTuple_GET_SIZE(__pyx_args)) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
         CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
         break;
         default: goto __pyx_L5_argtuple_error;
       }
@@ -2584,10 +4320,18 @@ static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_imp
     __pyx_v_input_binstates = values[0];
     __pyx_v_verbose = values[1];
   }
-  goto __pyx_L4_argument_unpacking_done;
+  goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("find_implicants_qm", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 66, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("find_implicants_qm", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 68, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_AddTraceback("cana.canalization.cboolean_canalization.find_implicants_qm", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
   return NULL;
@@ -2595,6 +4339,12 @@ static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_9find_imp
   __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_8find_implicants_qm(__pyx_self, __pyx_v_input_binstates, __pyx_v_verbose);
 
   /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
@@ -2617,9 +4367,9 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   int __pyx_t_2;
   PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
-  Py_ssize_t __pyx_t_5;
-  PyObject *(*__pyx_t_6)(PyObject *);
-  int __pyx_t_7;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  PyObject *(*__pyx_t_7)(PyObject *);
   Py_ssize_t __pyx_t_8;
   PyObject *(*__pyx_t_9)(PyObject *);
   PyObject *__pyx_t_10 = NULL;
@@ -2630,28 +4380,26 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   PyObject *__pyx_t_15 = NULL;
   int __pyx_t_16;
   PyObject *__pyx_t_17 = NULL;
-  int __pyx_t_18;
-  PyObject *__pyx_t_19 = NULL;
-  PyObject *__pyx_t_20 = NULL;
+  PyObject *__pyx_t_18 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
   __Pyx_RefNannySetupContext("find_implicants_qm", 0);
   __Pyx_INCREF(__pyx_v_input_binstates);
 
-  /* "cana/canalization/cboolean_canalization.pyx":79
+  /* "cana/canalization/cboolean_canalization.pyx":81
  * 
  *     # we start with an empty set of implicants
  *     matched_implicants = set()             # <<<<<<<<<<<<<<
  *     done = False
  * 
  */
-  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __pyx_v_matched_implicants = __pyx_t_1;
   __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":80
+  /* "cana/canalization/cboolean_canalization.pyx":82
  *     # we start with an empty set of implicants
  *     matched_implicants = set()
  *     done = False             # <<<<<<<<<<<<<<
@@ -2660,7 +4408,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  */
   __pyx_v_done = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":83
+  /* "cana/canalization/cboolean_canalization.pyx":85
  * 
  *     # repeat the following until no matches are found
  *     while not done:             # <<<<<<<<<<<<<<
@@ -2668,61 +4416,68 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  *         # split up the input_binstates into groups based on the number of 1s (density)
  */
   while (1) {
-    __pyx_t_2 = ((!(__pyx_v_done != 0)) != 0);
+    __pyx_t_2 = (!__pyx_v_done);
     if (!__pyx_t_2) break;
 
-    /* "cana/canalization/cboolean_canalization.pyx":86
+    /* "cana/canalization/cboolean_canalization.pyx":88
  * 
  *         # split up the input_binstates into groups based on the number of 1s (density)
  *         density_groups = make_density_groups(input_binstates)             # <<<<<<<<<<<<<<
  * 
  *         # now clear everything for the new pass
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_make_density_groups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_make_density_groups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 88, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __pyx_t_4 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_3))) {
       __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
       if (likely(__pyx_t_4)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
         __Pyx_INCREF(__pyx_t_4);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_3, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_input_binstates) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_input_binstates);
-    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_input_binstates};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    }
     __Pyx_XDECREF_SET(__pyx_v_density_groups, __pyx_t_1);
     __pyx_t_1 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":89
+    /* "cana/canalization/cboolean_canalization.pyx":91
  * 
  *         # now clear everything for the new pass
  *         input_binstates = set()             # <<<<<<<<<<<<<<
  *         used = set()
  * 
  */
-    __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error)
+    __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF_SET(__pyx_v_input_binstates, __pyx_t_1);
     __pyx_t_1 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":90
+    /* "cana/canalization/cboolean_canalization.pyx":92
  *         # now clear everything for the new pass
  *         input_binstates = set()
  *         used = set()             # <<<<<<<<<<<<<<
  * 
  *         # Find the prime implicants
  */
-    __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error)
+    __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_XDECREF_SET(__pyx_v_used, ((PyObject*)__pyx_t_1));
     __pyx_t_1 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":95
+    /* "cana/canalization/cboolean_canalization.pyx":97
  * 
  *         # for each possible density
  *         for density in density_groups:             # <<<<<<<<<<<<<<
@@ -2730,39 +4485,52 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  *             if density + 1 in density_groups:
  */
     if (likely(PyList_CheckExact(__pyx_v_density_groups)) || PyTuple_CheckExact(__pyx_v_density_groups)) {
-      __pyx_t_1 = __pyx_v_density_groups; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
-      __pyx_t_6 = NULL;
+      __pyx_t_1 = __pyx_v_density_groups; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_6 = 0;
+      __pyx_t_7 = NULL;
     } else {
-      __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_density_groups); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_density_groups); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 97, __pyx_L1_error)
     }
     for (;;) {
-      if (likely(!__pyx_t_6)) {
+      if (likely(!__pyx_t_7)) {
         if (likely(PyList_CheckExact(__pyx_t_1))) {
-          if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 97, __pyx_L1_error)
+            #endif
+            if (__pyx_t_6 >= __pyx_temp) break;
+          }
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 95, __pyx_L1_error)
+          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 97, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error)
+          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_3);
           #endif
         } else {
-          if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 97, __pyx_L1_error)
+            #endif
+            if (__pyx_t_6 >= __pyx_temp) break;
+          }
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 95, __pyx_L1_error)
+          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 97, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 95, __pyx_L1_error)
+          __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_3);
           #endif
         }
       } else {
-        __pyx_t_3 = __pyx_t_6(__pyx_t_1);
+        __pyx_t_3 = __pyx_t_7(__pyx_t_1);
         if (unlikely(!__pyx_t_3)) {
           PyObject* exc_type = PyErr_Occurred();
           if (exc_type) {
             if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(0, 95, __pyx_L1_error)
+            else __PYX_ERR(0, 97, __pyx_L1_error)
           }
           break;
         }
@@ -2771,54 +4539,66 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
       __Pyx_XDECREF_SET(__pyx_v_density, __pyx_t_3);
       __pyx_t_3 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":97
+      /* "cana/canalization/cboolean_canalization.pyx":99
  *         for density in density_groups:
  *             # first make sure there are other binstates with the next density
  *             if density + 1 in density_groups:             # <<<<<<<<<<<<<<
  * 
  *                 # then we pass through the binstates
  */
-      __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_density, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
+      __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_density, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 99, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_v_density_groups, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 97, __pyx_L1_error)
+      __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_v_density_groups, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 99, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_7 = (__pyx_t_2 != 0);
-      if (__pyx_t_7) {
+      if (__pyx_t_2) {
 
-        /* "cana/canalization/cboolean_canalization.pyx":100
+        /* "cana/canalization/cboolean_canalization.pyx":102
  * 
  *                 # then we pass through the binstates
  *                 for binstate0 in density_groups[density]:             # <<<<<<<<<<<<<<
  * 
  *                     # An optimization due to Thomas Pircher, https://github.com/tpircher/quine-mccluskey/blob/master/quine_mccluskey/qm.py
  */
-        __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_density_groups, __pyx_v_density); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error)
+        __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_density_groups, __pyx_v_density); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_3);
         if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
-          __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_8 = 0;
+          __pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4);
+          __pyx_t_8 = 0;
           __pyx_t_9 = NULL;
         } else {
-          __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error)
+          __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 102, __pyx_L1_error)
           __Pyx_GOTREF(__pyx_t_4);
-          __pyx_t_9 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 100, __pyx_L1_error)
+          __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 102, __pyx_L1_error)
         }
         __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
         for (;;) {
           if (likely(!__pyx_t_9)) {
             if (likely(PyList_CheckExact(__pyx_t_4))) {
-              if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_4)) break;
+              {
+                Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+                #if !CYTHON_ASSUME_SAFE_MACROS
+                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 102, __pyx_L1_error)
+                #endif
+                if (__pyx_t_8 >= __pyx_temp) break;
+              }
               #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-              __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 100, __pyx_L1_error)
+              __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 102, __pyx_L1_error)
               #else
-              __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error)
+              __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
               __Pyx_GOTREF(__pyx_t_3);
               #endif
             } else {
-              if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
+              {
+                Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4);
+                #if !CYTHON_ASSUME_SAFE_MACROS
+                if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 102, __pyx_L1_error)
+                #endif
+                if (__pyx_t_8 >= __pyx_temp) break;
+              }
               #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-              __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 100, __pyx_L1_error)
+              __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 102, __pyx_L1_error)
               #else
-              __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 100, __pyx_L1_error)
+              __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 102, __pyx_L1_error)
               __Pyx_GOTREF(__pyx_t_3);
               #endif
             }
@@ -2828,7 +4608,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
               PyObject* exc_type = PyErr_Occurred();
               if (exc_type) {
                 if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-                else __PYX_ERR(0, 100, __pyx_L1_error)
+                else __PYX_ERR(0, 102, __pyx_L1_error)
               }
               break;
             }
@@ -2837,7 +4617,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
           __Pyx_XDECREF_SET(__pyx_v_binstate0, __pyx_t_3);
           __pyx_t_3 = 0;
 
-          /* "cana/canalization/cboolean_canalization.pyx":110
+          /* "cana/canalization/cboolean_canalization.pyx":112
  *                     # contained in the set groups[key_next].
  * 
  *                     for idx, b0 in enumerate(binstate0):             # <<<<<<<<<<<<<<
@@ -2847,29 +4627,42 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
           __Pyx_INCREF(__pyx_int_0);
           __pyx_t_3 = __pyx_int_0;
           if (likely(PyList_CheckExact(__pyx_v_binstate0)) || PyTuple_CheckExact(__pyx_v_binstate0)) {
-            __pyx_t_10 = __pyx_v_binstate0; __Pyx_INCREF(__pyx_t_10); __pyx_t_11 = 0;
+            __pyx_t_10 = __pyx_v_binstate0; __Pyx_INCREF(__pyx_t_10);
+            __pyx_t_11 = 0;
             __pyx_t_12 = NULL;
           } else {
-            __pyx_t_11 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_v_binstate0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 110, __pyx_L1_error)
+            __pyx_t_11 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_v_binstate0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 112, __pyx_L1_error)
             __Pyx_GOTREF(__pyx_t_10);
-            __pyx_t_12 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 110, __pyx_L1_error)
+            __pyx_t_12 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 112, __pyx_L1_error)
           }
           for (;;) {
             if (likely(!__pyx_t_12)) {
               if (likely(PyList_CheckExact(__pyx_t_10))) {
-                if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_10)) break;
+                {
+                  Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_10);
+                  #if !CYTHON_ASSUME_SAFE_MACROS
+                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 112, __pyx_L1_error)
+                  #endif
+                  if (__pyx_t_11 >= __pyx_temp) break;
+                }
                 #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-                __pyx_t_13 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 110, __pyx_L1_error)
+                __pyx_t_13 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely((0 < 0))) __PYX_ERR(0, 112, __pyx_L1_error)
                 #else
-                __pyx_t_13 = PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 110, __pyx_L1_error)
+                __pyx_t_13 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
                 __Pyx_GOTREF(__pyx_t_13);
                 #endif
               } else {
-                if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
+                {
+                  Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_10);
+                  #if !CYTHON_ASSUME_SAFE_MACROS
+                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 112, __pyx_L1_error)
+                  #endif
+                  if (__pyx_t_11 >= __pyx_temp) break;
+                }
                 #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-                __pyx_t_13 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 110, __pyx_L1_error)
+                __pyx_t_13 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely((0 < 0))) __PYX_ERR(0, 112, __pyx_L1_error)
                 #else
-                __pyx_t_13 = PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 110, __pyx_L1_error)
+                __pyx_t_13 = __Pyx_PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
                 __Pyx_GOTREF(__pyx_t_13);
                 #endif
               }
@@ -2879,7 +4672,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
                 PyObject* exc_type = PyErr_Occurred();
                 if (exc_type) {
                   if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-                  else __PYX_ERR(0, 110, __pyx_L1_error)
+                  else __PYX_ERR(0, 112, __pyx_L1_error)
                 }
                 break;
               }
@@ -2889,189 +4682,149 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
             __pyx_t_13 = 0;
             __Pyx_INCREF(__pyx_t_3);
             __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3);
-            __pyx_t_13 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 110, __pyx_L1_error)
+            __pyx_t_13 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
             __Pyx_GOTREF(__pyx_t_13);
             __Pyx_DECREF(__pyx_t_3);
             __pyx_t_3 = __pyx_t_13;
             __pyx_t_13 = 0;
 
-            /* "cana/canalization/cboolean_canalization.pyx":111
+            /* "cana/canalization/cboolean_canalization.pyx":113
  * 
  *                     for idx, b0 in enumerate(binstate0):
  *                         if b0 == '0':             # <<<<<<<<<<<<<<
  *                             binstate1 = flip_binstate_bit(binstate0, idx)
  *                             if binstate1 in density_groups[density + 1]:
  */
-            __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_v_b0, __pyx_kp_s_0, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 111, __pyx_L1_error)
-            if (__pyx_t_7) {
+            __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_b0, __pyx_kp_u_0, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 113, __pyx_L1_error)
+            if (__pyx_t_2) {
 
-              /* "cana/canalization/cboolean_canalization.pyx":112
+              /* "cana/canalization/cboolean_canalization.pyx":114
  *                     for idx, b0 in enumerate(binstate0):
  *                         if b0 == '0':
  *                             binstate1 = flip_binstate_bit(binstate0, idx)             # <<<<<<<<<<<<<<
  *                             if binstate1 in density_groups[density + 1]:
  *                                 # keep track of the covered binary states
  */
-              __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_n_s_flip_binstate_bit); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 112, __pyx_L1_error)
+              __Pyx_GetModuleGlobalName(__pyx_t_14, __pyx_n_s_flip_binstate_bit); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 114, __pyx_L1_error)
               __Pyx_GOTREF(__pyx_t_14);
               __pyx_t_15 = NULL;
-              __pyx_t_16 = 0;
-              if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_14))) {
+              __pyx_t_5 = 0;
+              #if CYTHON_UNPACK_METHODS
+              if (unlikely(PyMethod_Check(__pyx_t_14))) {
                 __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
                 if (likely(__pyx_t_15)) {
                   PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
                   __Pyx_INCREF(__pyx_t_15);
                   __Pyx_INCREF(function);
                   __Pyx_DECREF_SET(__pyx_t_14, function);
-                  __pyx_t_16 = 1;
+                  __pyx_t_5 = 1;
                 }
               }
-              #if CYTHON_FAST_PYCALL
-              if (PyFunction_Check(__pyx_t_14)) {
-                PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_binstate0, __pyx_v_idx};
-                __pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
-                __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
-                __Pyx_GOTREF(__pyx_t_13);
-              } else
-              #endif
-              #if CYTHON_FAST_PYCCALL
-              if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
-                PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_binstate0, __pyx_v_idx};
-                __pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
-                __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
-                __Pyx_GOTREF(__pyx_t_13);
-              } else
               #endif
               {
-                __pyx_t_17 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 112, __pyx_L1_error)
-                __Pyx_GOTREF(__pyx_t_17);
-                if (__pyx_t_15) {
-                  __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_15); __pyx_t_15 = NULL;
-                }
-                __Pyx_INCREF(__pyx_v_binstate0);
-                __Pyx_GIVEREF(__pyx_v_binstate0);
-                PyTuple_SET_ITEM(__pyx_t_17, 0+__pyx_t_16, __pyx_v_binstate0);
-                __Pyx_INCREF(__pyx_v_idx);
-                __Pyx_GIVEREF(__pyx_v_idx);
-                PyTuple_SET_ITEM(__pyx_t_17, 1+__pyx_t_16, __pyx_v_idx);
-                __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_17, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 112, __pyx_L1_error)
+                PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_v_binstate0, __pyx_v_idx};
+                __pyx_t_13 = __Pyx_PyObject_FastCall(__pyx_t_14, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5);
+                __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
+                if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 114, __pyx_L1_error)
                 __Pyx_GOTREF(__pyx_t_13);
-                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
+                __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
               }
-              __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
               __Pyx_XDECREF_SET(__pyx_v_binstate1, __pyx_t_13);
               __pyx_t_13 = 0;
 
-              /* "cana/canalization/cboolean_canalization.pyx":113
+              /* "cana/canalization/cboolean_canalization.pyx":115
  *                         if b0 == '0':
  *                             binstate1 = flip_binstate_bit(binstate0, idx)
  *                             if binstate1 in density_groups[density + 1]:             # <<<<<<<<<<<<<<
  *                                 # keep track of the covered binary states
  *                                 used.add(binstate0)
  */
-              __pyx_t_13 = __Pyx_PyInt_AddObjC(__pyx_v_density, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 113, __pyx_L1_error)
+              __pyx_t_13 = __Pyx_PyInt_AddObjC(__pyx_v_density, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 115, __pyx_L1_error)
               __Pyx_GOTREF(__pyx_t_13);
-              __pyx_t_14 = __Pyx_PyObject_GetItem(__pyx_v_density_groups, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 113, __pyx_L1_error)
+              __pyx_t_14 = __Pyx_PyObject_GetItem(__pyx_v_density_groups, __pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 115, __pyx_L1_error)
               __Pyx_GOTREF(__pyx_t_14);
               __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-              __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_binstate1, __pyx_t_14, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 113, __pyx_L1_error)
+              __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_binstate1, __pyx_t_14, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 115, __pyx_L1_error)
               __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-              __pyx_t_2 = (__pyx_t_7 != 0);
               if (__pyx_t_2) {
 
-                /* "cana/canalization/cboolean_canalization.pyx":115
+                /* "cana/canalization/cboolean_canalization.pyx":117
  *                             if binstate1 in density_groups[density + 1]:
  *                                 # keep track of the covered binary states
  *                                 used.add(binstate0)             # <<<<<<<<<<<<<<
  *                                 used.add(binstate1)
  *                                 # keep the new wildcard binstate for the next round
  */
-                __pyx_t_18 = PySet_Add(__pyx_v_used, __pyx_v_binstate0); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 115, __pyx_L1_error)
+                __pyx_t_16 = PySet_Add(__pyx_v_used, __pyx_v_binstate0); if (unlikely(__pyx_t_16 == ((int)-1))) __PYX_ERR(0, 117, __pyx_L1_error)
 
-                /* "cana/canalization/cboolean_canalization.pyx":116
+                /* "cana/canalization/cboolean_canalization.pyx":118
  *                                 # keep track of the covered binary states
  *                                 used.add(binstate0)
  *                                 used.add(binstate1)             # <<<<<<<<<<<<<<
  *                                 # keep the new wildcard binstate for the next round
  *                                 input_binstates.add(replace_wildcard(binstate0, idx))
  */
-                __pyx_t_18 = PySet_Add(__pyx_v_used, __pyx_v_binstate1); if (unlikely(__pyx_t_18 == ((int)-1))) __PYX_ERR(0, 116, __pyx_L1_error)
+                __pyx_t_16 = PySet_Add(__pyx_v_used, __pyx_v_binstate1); if (unlikely(__pyx_t_16 == ((int)-1))) __PYX_ERR(0, 118, __pyx_L1_error)
 
-                /* "cana/canalization/cboolean_canalization.pyx":118
+                /* "cana/canalization/cboolean_canalization.pyx":120
  *                                 used.add(binstate1)
  *                                 # keep the new wildcard binstate for the next round
  *                                 input_binstates.add(replace_wildcard(binstate0, idx))             # <<<<<<<<<<<<<<
  * 
  *         # now add back the implicants that were not matched
  */
-                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_binstates, __pyx_n_s_add); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 118, __pyx_L1_error)
+                __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_input_binstates, __pyx_n_s_add); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 120, __pyx_L1_error)
                 __Pyx_GOTREF(__pyx_t_13);
-                __Pyx_GetModuleGlobalName(__pyx_t_15, __pyx_n_s_replace_wildcard); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 118, __pyx_L1_error)
-                __Pyx_GOTREF(__pyx_t_15);
-                __pyx_t_19 = NULL;
-                __pyx_t_16 = 0;
-                if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_15))) {
-                  __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_15);
-                  if (likely(__pyx_t_19)) {
-                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
-                    __Pyx_INCREF(__pyx_t_19);
+                __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_replace_wildcard); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 120, __pyx_L1_error)
+                __Pyx_GOTREF(__pyx_t_17);
+                __pyx_t_18 = NULL;
+                __pyx_t_5 = 0;
+                #if CYTHON_UNPACK_METHODS
+                if (unlikely(PyMethod_Check(__pyx_t_17))) {
+                  __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_17);
+                  if (likely(__pyx_t_18)) {
+                    PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_17);
+                    __Pyx_INCREF(__pyx_t_18);
                     __Pyx_INCREF(function);
-                    __Pyx_DECREF_SET(__pyx_t_15, function);
-                    __pyx_t_16 = 1;
+                    __Pyx_DECREF_SET(__pyx_t_17, function);
+                    __pyx_t_5 = 1;
                   }
                 }
-                #if CYTHON_FAST_PYCALL
-                if (PyFunction_Check(__pyx_t_15)) {
-                  PyObject *__pyx_temp[3] = {__pyx_t_19, __pyx_v_binstate0, __pyx_v_idx};
-                  __pyx_t_17 = __Pyx_PyFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 118, __pyx_L1_error)
-                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
-                  __Pyx_GOTREF(__pyx_t_17);
-                } else
-                #endif
-                #if CYTHON_FAST_PYCCALL
-                if (__Pyx_PyFastCFunction_Check(__pyx_t_15)) {
-                  PyObject *__pyx_temp[3] = {__pyx_t_19, __pyx_v_binstate0, __pyx_v_idx};
-                  __pyx_t_17 = __Pyx_PyCFunction_FastCall(__pyx_t_15, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 118, __pyx_L1_error)
-                  __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
-                  __Pyx_GOTREF(__pyx_t_17);
-                } else
                 #endif
                 {
-                  __pyx_t_20 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 118, __pyx_L1_error)
-                  __Pyx_GOTREF(__pyx_t_20);
-                  if (__pyx_t_19) {
-                    __Pyx_GIVEREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_19); __pyx_t_19 = NULL;
-                  }
-                  __Pyx_INCREF(__pyx_v_binstate0);
-                  __Pyx_GIVEREF(__pyx_v_binstate0);
-                  PyTuple_SET_ITEM(__pyx_t_20, 0+__pyx_t_16, __pyx_v_binstate0);
-                  __Pyx_INCREF(__pyx_v_idx);
-                  __Pyx_GIVEREF(__pyx_v_idx);
-                  PyTuple_SET_ITEM(__pyx_t_20, 1+__pyx_t_16, __pyx_v_idx);
-                  __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_20, NULL); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 118, __pyx_L1_error)
-                  __Pyx_GOTREF(__pyx_t_17);
-                  __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
+                  PyObject *__pyx_callargs[3] = {__pyx_t_18, __pyx_v_binstate0, __pyx_v_idx};
+                  __pyx_t_15 = __Pyx_PyObject_FastCall(__pyx_t_17, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5);
+                  __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
+                  if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 120, __pyx_L1_error)
+                  __Pyx_GOTREF(__pyx_t_15);
+                  __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
                 }
-                __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
-                __pyx_t_15 = NULL;
-                if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
-                  __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_13);
-                  if (likely(__pyx_t_15)) {
+                __pyx_t_17 = NULL;
+                __pyx_t_5 = 0;
+                #if CYTHON_UNPACK_METHODS
+                if (likely(PyMethod_Check(__pyx_t_13))) {
+                  __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_13);
+                  if (likely(__pyx_t_17)) {
                     PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
-                    __Pyx_INCREF(__pyx_t_15);
+                    __Pyx_INCREF(__pyx_t_17);
                     __Pyx_INCREF(function);
                     __Pyx_DECREF_SET(__pyx_t_13, function);
+                    __pyx_t_5 = 1;
                   }
                 }
-                __pyx_t_14 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_15, __pyx_t_17) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_17);
-                __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
-                __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
-                if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 118, __pyx_L1_error)
-                __Pyx_GOTREF(__pyx_t_14);
-                __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                #endif
+                {
+                  PyObject *__pyx_callargs[2] = {__pyx_t_17, __pyx_t_15};
+                  __pyx_t_14 = __Pyx_PyObject_FastCall(__pyx_t_13, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+                  __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
+                  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+                  if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 120, __pyx_L1_error)
+                  __Pyx_GOTREF(__pyx_t_14);
+                  __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+                }
                 __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
 
-                /* "cana/canalization/cboolean_canalization.pyx":113
+                /* "cana/canalization/cboolean_canalization.pyx":115
  *                         if b0 == '0':
  *                             binstate1 = flip_binstate_bit(binstate0, idx)
  *                             if binstate1 in density_groups[density + 1]:             # <<<<<<<<<<<<<<
@@ -3080,7 +4833,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  */
               }
 
-              /* "cana/canalization/cboolean_canalization.pyx":111
+              /* "cana/canalization/cboolean_canalization.pyx":113
  * 
  *                     for idx, b0 in enumerate(binstate0):
  *                         if b0 == '0':             # <<<<<<<<<<<<<<
@@ -3089,7 +4842,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  */
             }
 
-            /* "cana/canalization/cboolean_canalization.pyx":110
+            /* "cana/canalization/cboolean_canalization.pyx":112
  *                     # contained in the set groups[key_next].
  * 
  *                     for idx, b0 in enumerate(binstate0):             # <<<<<<<<<<<<<<
@@ -3100,7 +4853,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
           __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
           __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-          /* "cana/canalization/cboolean_canalization.pyx":100
+          /* "cana/canalization/cboolean_canalization.pyx":102
  * 
  *                 # then we pass through the binstates
  *                 for binstate0 in density_groups[density]:             # <<<<<<<<<<<<<<
@@ -3110,7 +4863,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
         }
         __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-        /* "cana/canalization/cboolean_canalization.pyx":97
+        /* "cana/canalization/cboolean_canalization.pyx":99
  *         for density in density_groups:
  *             # first make sure there are other binstates with the next density
  *             if density + 1 in density_groups:             # <<<<<<<<<<<<<<
@@ -3119,7 +4872,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  */
       }
 
-      /* "cana/canalization/cboolean_canalization.pyx":95
+      /* "cana/canalization/cboolean_canalization.pyx":97
  * 
  *         # for each possible density
  *         for density in density_groups:             # <<<<<<<<<<<<<<
@@ -3129,62 +4882,76 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
     }
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":121
+    /* "cana/canalization/cboolean_canalization.pyx":123
  * 
  *         # now add back the implicants that were not matched
  *         for groups in list(density_groups.values()):             # <<<<<<<<<<<<<<
  *             matched_implicants |= groups - used
  * 
  */
-    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_density_groups, __pyx_n_s_values); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)
+    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_density_groups, __pyx_n_s_values); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __pyx_t_3 = NULL;
-    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_5 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (likely(PyMethod_Check(__pyx_t_4))) {
       __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
       if (likely(__pyx_t_3)) {
         PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
         __Pyx_INCREF(__pyx_t_3);
         __Pyx_INCREF(function);
         __Pyx_DECREF_SET(__pyx_t_4, function);
+        __pyx_t_5 = 1;
       }
     }
-    __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __pyx_t_4 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL};
+      __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5);
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 123, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+    __pyx_t_4 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_4);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
+    __pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_6 = 0;
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     for (;;) {
-      if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      {
+        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 123, __pyx_L1_error)
+        #endif
+        if (__pyx_t_6 >= __pyx_temp) break;
+      }
       #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 121, __pyx_L1_error)
+      __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 123, __pyx_L1_error)
       #else
-      __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)
+      __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
       #endif
       __Pyx_XDECREF_SET(__pyx_v_groups, __pyx_t_4);
       __pyx_t_4 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":122
+      /* "cana/canalization/cboolean_canalization.pyx":124
  *         # now add back the implicants that were not matched
  *         for groups in list(density_groups.values()):
  *             matched_implicants |= groups - used             # <<<<<<<<<<<<<<
  * 
  *         # finally, check if this pass actually compressed any terms
  */
-      __pyx_t_4 = PyNumber_Subtract(__pyx_v_groups, __pyx_v_used); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error)
+      __pyx_t_4 = PyNumber_Subtract(__pyx_v_groups, __pyx_v_used); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 124, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_4);
-      __pyx_t_3 = PyNumber_InPlaceOr(__pyx_v_matched_implicants, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 122, __pyx_L1_error)
+      __pyx_t_3 = PyNumber_InPlaceOr(__pyx_v_matched_implicants, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_3);
       __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
       __Pyx_DECREF_SET(__pyx_v_matched_implicants, __pyx_t_3);
       __pyx_t_3 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":121
+      /* "cana/canalization/cboolean_canalization.pyx":123
  * 
  *         # now add back the implicants that were not matched
  *         for groups in list(density_groups.values()):             # <<<<<<<<<<<<<<
@@ -3194,18 +4961,18 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
     }
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":126
+    /* "cana/canalization/cboolean_canalization.pyx":128
  *         # finally, check if this pass actually compressed any terms
  *         # we finish when we cant make any further compressions
  *         if len(used) == 0:             # <<<<<<<<<<<<<<
  *             done = True
  * 
  */
-    __pyx_t_5 = PySet_GET_SIZE(__pyx_v_used); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 126, __pyx_L1_error)
-    __pyx_t_2 = ((__pyx_t_5 == 0) != 0);
+    __pyx_t_6 = __Pyx_PySet_GET_SIZE(__pyx_v_used); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 128, __pyx_L1_error)
+    __pyx_t_2 = (__pyx_t_6 == 0);
     if (__pyx_t_2) {
 
-      /* "cana/canalization/cboolean_canalization.pyx":127
+      /* "cana/canalization/cboolean_canalization.pyx":129
  *         # we finish when we cant make any further compressions
  *         if len(used) == 0:
  *             done = True             # <<<<<<<<<<<<<<
@@ -3214,7 +4981,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
  */
       __pyx_v_done = 1;
 
-      /* "cana/canalization/cboolean_canalization.pyx":126
+      /* "cana/canalization/cboolean_canalization.pyx":128
  *         # finally, check if this pass actually compressed any terms
  *         # we finish when we cant make any further compressions
  *         if len(used) == 0:             # <<<<<<<<<<<<<<
@@ -3224,7 +4991,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
     }
   }
 
-  /* "cana/canalization/cboolean_canalization.pyx":130
+  /* "cana/canalization/cboolean_canalization.pyx":132
  * 
  *     # finish up by adding back all of the uncovered binary states
  *     prime_implicants = matched_implicants             # <<<<<<<<<<<<<<
@@ -3234,60 +5001,74 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   __Pyx_INCREF(__pyx_v_matched_implicants);
   __pyx_v_prime_implicants = __pyx_v_matched_implicants;
 
-  /* "cana/canalization/cboolean_canalization.pyx":131
+  /* "cana/canalization/cboolean_canalization.pyx":133
  *     # finish up by adding back all of the uncovered binary states
  *     prime_implicants = matched_implicants
  *     for groups in list(density_groups.values()):             # <<<<<<<<<<<<<<
  *         prime_implicants |= groups
  * 
  */
-  if (unlikely(!__pyx_v_density_groups)) { __Pyx_RaiseUnboundLocalError("density_groups"); __PYX_ERR(0, 131, __pyx_L1_error) }
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_density_groups, __pyx_n_s_values); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+  if (unlikely(!__pyx_v_density_groups)) { __Pyx_RaiseUnboundLocalError("density_groups"); __PYX_ERR(0, 133, __pyx_L1_error) }
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_density_groups, __pyx_n_s_values); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+  __pyx_t_5 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_3))) {
     __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
     if (likely(__pyx_t_4)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
       __Pyx_INCREF(__pyx_t_4);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_3, function);
+      __pyx_t_5 = 1;
     }
   }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+  #endif
+  {
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+  __pyx_t_3 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
+  __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1);
+  __pyx_t_6 = 0;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   for (;;) {
-    if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
+    {
+      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+      #if !CYTHON_ASSUME_SAFE_MACROS
+      if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 133, __pyx_L1_error)
+      #endif
+      if (__pyx_t_6 >= __pyx_temp) break;
+    }
     #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 133, __pyx_L1_error)
     #else
-    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     #endif
     __Pyx_XDECREF_SET(__pyx_v_groups, __pyx_t_3);
     __pyx_t_3 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":132
+    /* "cana/canalization/cboolean_canalization.pyx":134
  *     prime_implicants = matched_implicants
  *     for groups in list(density_groups.values()):
  *         prime_implicants |= groups             # <<<<<<<<<<<<<<
  * 
  *     return prime_implicants
  */
-    __pyx_t_3 = PyNumber_InPlaceOr(__pyx_v_prime_implicants, __pyx_v_groups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error)
+    __pyx_t_3 = PyNumber_InPlaceOr(__pyx_v_prime_implicants, __pyx_v_groups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 134, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF_SET(__pyx_v_prime_implicants, __pyx_t_3);
     __pyx_t_3 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":131
+    /* "cana/canalization/cboolean_canalization.pyx":133
  *     # finish up by adding back all of the uncovered binary states
  *     prime_implicants = matched_implicants
  *     for groups in list(density_groups.values()):             # <<<<<<<<<<<<<<
@@ -3297,7 +5078,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   }
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":134
+  /* "cana/canalization/cboolean_canalization.pyx":136
  *         prime_implicants |= groups
  * 
  *     return prime_implicants             # <<<<<<<<<<<<<<
@@ -3309,7 +5090,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   __pyx_r = __pyx_v_prime_implicants;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":66
+  /* "cana/canalization/cboolean_canalization.pyx":68
  * 
  * 
  * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
@@ -3327,8 +5108,7 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   __Pyx_XDECREF(__pyx_t_14);
   __Pyx_XDECREF(__pyx_t_15);
   __Pyx_XDECREF(__pyx_t_17);
-  __Pyx_XDECREF(__pyx_t_19);
-  __Pyx_XDECREF(__pyx_t_20);
+  __Pyx_XDECREF(__pyx_t_18);
   __Pyx_AddTraceback("cana.canalization.cboolean_canalization.find_implicants_qm", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;
@@ -3348,4356 +5128,9540 @@ static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_8find_imp
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":137
+/* "cana/canalization/cboolean_canalization.pyx":140
  * 
- * 
- * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
+ * @cython.cfunc
+ * cdef inline bint _is_wildcard_symbol(object symbol):             # <<<<<<<<<<<<<<
+ *     return (
+ *         symbol == WILDCARD_SYMBOL
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_11__pi_covers(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_10__pi_covers[] = "Determines if a binarystate is covered by a specific implicant.\n    Args:\n        implicant (string): the implicant.\n        minterm (string): the minterm.\n    Returns:\n        x (bool): True if covered else False.\n\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_11__pi_covers = {"__pi_covers", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_11__pi_covers, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_10__pi_covers};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_11__pi_covers(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyObject *__pyx_v_implicant = 0;
-  CYTHON_UNUSED PyObject *__pyx_v_binstate = 0;
+static CYTHON_INLINE int __pyx_f_4cana_12canalization_21cboolean_canalization__is_wildcard_symbol(PyObject *__pyx_v_symbol) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__pi_covers (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_implicant,&__pyx_n_s_binstate,0};
-    PyObject* values[2] = {0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_implicant)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_binstate)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("__pi_covers", 1, 2, 2, 1); __PYX_ERR(0, 137, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pi_covers") < 0)) __PYX_ERR(0, 137, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-    }
-    __pyx_v_implicant = values[0];
-    __pyx_v_binstate = values[1];
+  __Pyx_RefNannySetupContext("_is_wildcard_symbol", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":142
+ * cdef inline bint _is_wildcard_symbol(object symbol):
+ *     return (
+ *         symbol == WILDCARD_SYMBOL             # <<<<<<<<<<<<<<
+ *         or symbol == SYMMETRIC_WILDCARD_SYMBOL
+ *         or symbol == '2'
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyObject_RichCompare(__pyx_v_symbol, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L3_bool_binop_done;
   }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("__pi_covers", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 137, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.__pi_covers", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_10__pi_covers(__pyx_self, __pyx_v_implicant, __pyx_v_binstate);
+
+  /* "cana/canalization/cboolean_canalization.pyx":143
+ *     return (
+ *         symbol == WILDCARD_SYMBOL
+ *         or symbol == SYMMETRIC_WILDCARD_SYMBOL             # <<<<<<<<<<<<<<
+ *         or symbol == '2'
+ *         or symbol == 2
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyObject_RichCompare(__pyx_v_symbol, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L3_bool_binop_done;
+  }
+
+  /* "cana/canalization/cboolean_canalization.pyx":144
+ *         symbol == WILDCARD_SYMBOL
+ *         or symbol == SYMMETRIC_WILDCARD_SYMBOL
+ *         or symbol == '2'             # <<<<<<<<<<<<<<
+ *         or symbol == 2
+ *     )
+ */
+  __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_symbol, __pyx_kp_u_2, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 144, __pyx_L1_error)
+  if (!__pyx_t_4) {
+  } else {
+    __pyx_t_1 = __pyx_t_4;
+    goto __pyx_L3_bool_binop_done;
+  }
+
+  /* "cana/canalization/cboolean_canalization.pyx":145
+ *         or symbol == SYMMETRIC_WILDCARD_SYMBOL
+ *         or symbol == '2'
+ *         or symbol == 2             # <<<<<<<<<<<<<<
+ *     )
+ * 
+ */
+  __pyx_t_4 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_symbol, __pyx_int_2, 2, 0)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 145, __pyx_L1_error)
+  __pyx_t_1 = __pyx_t_4;
+  __pyx_L3_bool_binop_done:;
+  __pyx_r = __pyx_t_1;
+  goto __pyx_L0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":140
+ * 
+ * @cython.cfunc
+ * cdef inline bint _is_wildcard_symbol(object symbol):             # <<<<<<<<<<<<<<
+ *     return (
+ *         symbol == WILDCARD_SYMBOL
+ */
 
   /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization._is_wildcard_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
-static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_11__pi_covers_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
 
-/* "cana/canalization/cboolean_canalization.pyx":146
- * 
- *     """
- *     return all(i == WILDCARD_SYMBOL or m == i for i, m in zip(implicant, input))             # <<<<<<<<<<<<<<
- * 
- * 
+/* "cana/canalization/cboolean_canalization.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint pi_covers_fast(object implicant, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage check for wildcard schemata."""
+ *     cdef list imp_list
  */
 
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_11__pi_covers_genexpr(PyObject *__pyx_self) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_cur_scope;
-  PyObject *__pyx_r = NULL;
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_11pi_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static int __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(PyObject *__pyx_v_implicant, PyObject *__pyx_v_binstate, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  PyObject *__pyx_v_imp_list = 0;
+  Py_ssize_t __pyx_v_i;
+  Py_ssize_t __pyx_v_n;
+  PyObject *__pyx_v_symbol = 0;
+  PyObject *__pyx_v_binstate_str = 0;
+  PyObject *__pyx_8genexpr1__pyx_v_x = NULL;
+  int __pyx_r;
   __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("genexpr", 0);
-  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL);
-  if (unlikely(!__pyx_cur_scope)) {
-    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)Py_None);
-    __Pyx_INCREF(Py_None);
-    __PYX_ERR(0, 146, __pyx_L1_error)
-  } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
-  }
-  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *) __pyx_self;
-  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
-  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
-  {
-    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4cana_12canalization_21cboolean_canalization_11__pi_covers_2generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_pi_covers_locals_genexpr, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!gen)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_cur_scope);
-    __Pyx_RefNannyFinishContext();
-    return (PyObject *) gen;
-  }
-
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.__pi_covers.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_11__pi_covers_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
-{
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)__pyx_generator->closure);
-  PyObject *__pyx_r = NULL;
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  Py_ssize_t __pyx_t_3;
-  PyObject *(*__pyx_t_4)(PyObject *);
-  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
   PyObject *__pyx_t_6 = NULL;
-  PyObject *__pyx_t_7 = NULL;
-  PyObject *(*__pyx_t_8)(PyObject *);
-  int __pyx_t_9;
-  int __pyx_t_10;
+  Py_ssize_t __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_UCS4 __pyx_t_9;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("genexpr", 0);
-  switch (__pyx_generator->resume_label) {
-    case 0: goto __pyx_L3_first_run;
-    default: /* CPython raises the right error here */
-    __Pyx_RefNannyFinishContext();
-    return NULL;
-  }
-  __pyx_L3_first_run:;
-  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 146, __pyx_L1_error)
-  if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_implicant)) { __Pyx_RaiseClosureNameError("implicant"); __PYX_ERR(0, 146, __pyx_L1_error) }
-  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_implicant);
-  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_implicant);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_implicant);
-  __Pyx_INCREF(__pyx_builtin_input);
-  __Pyx_GIVEREF(__pyx_builtin_input);
-  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_input);
-  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
-    __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
-    __pyx_t_4 = NULL;
-  } else {
-    __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+  __Pyx_RefNannySetupContext("pi_covers_fast", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":156
+ *     cdef Py_ssize_t i, n
+ *     cdef object symbol
+ *     cdef str binstate_str = <str>binstate             # <<<<<<<<<<<<<<
+ * 
+ *     if isinstance(implicant, str):
+ */
+  __pyx_t_1 = __pyx_v_binstate;
+  __Pyx_INCREF(__pyx_t_1);
+  __pyx_v_binstate_str = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":158
+ *     cdef str binstate_str = <str>binstate
+ * 
+ *     if isinstance(implicant, str):             # <<<<<<<<<<<<<<
+ *         imp_list = list(implicant)
+ *     else:
+ */
+  __pyx_t_2 = PyUnicode_Check(__pyx_v_implicant); 
+  if (__pyx_t_2) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":159
+ * 
+ *     if isinstance(implicant, str):
+ *         imp_list = list(implicant)             # <<<<<<<<<<<<<<
+ *     else:
+ *         imp_list = [x for x in implicant]
+ */
+    __pyx_t_1 = PySequence_List(__pyx_v_implicant); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+    __pyx_v_imp_list = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":158
+ *     cdef str binstate_str = <str>binstate
+ * 
+ *     if isinstance(implicant, str):             # <<<<<<<<<<<<<<
+ *         imp_list = list(implicant)
+ *     else:
+ */
+    goto __pyx_L3;
   }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_4)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 146, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
+
+  /* "cana/canalization/cboolean_canalization.pyx":161
+ *         imp_list = list(implicant)
+ *     else:
+ *         imp_list = [x for x in implicant]             # <<<<<<<<<<<<<<
+ * 
+ *     n = len(imp_list)
+ */
+  /*else*/ {
+    { /* enter inner scope */
+      __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 161, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      if (likely(PyList_CheckExact(__pyx_v_implicant)) || PyTuple_CheckExact(__pyx_v_implicant)) {
+        __pyx_t_3 = __pyx_v_implicant; __Pyx_INCREF(__pyx_t_3);
+        __pyx_t_4 = 0;
+        __pyx_t_5 = NULL;
       } else {
-        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 146, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
+        __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_implicant); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 161, __pyx_L6_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 161, __pyx_L6_error)
       }
-    } else {
-      __pyx_t_2 = __pyx_t_4(__pyx_t_1);
-      if (unlikely(!__pyx_t_2)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 146, __pyx_L1_error)
+      for (;;) {
+        if (likely(!__pyx_t_5)) {
+          if (likely(PyList_CheckExact(__pyx_t_3))) {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 161, __pyx_L6_error)
+              #endif
+              if (__pyx_t_4 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 161, __pyx_L6_error)
+            #else
+            __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            #endif
+          } else {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 161, __pyx_L6_error)
+              #endif
+              if (__pyx_t_4 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 161, __pyx_L6_error)
+            #else
+            __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L6_error)
+            __Pyx_GOTREF(__pyx_t_6);
+            #endif
+          }
+        } else {
+          __pyx_t_6 = __pyx_t_5(__pyx_t_3);
+          if (unlikely(!__pyx_t_6)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+              else __PYX_ERR(0, 161, __pyx_L6_error)
+            }
+            break;
+          }
+          __Pyx_GOTREF(__pyx_t_6);
         }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_2);
-    }
-    if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
-      PyObject* sequence = __pyx_t_2;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(0, 146, __pyx_L1_error)
-      }
-      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); 
-      } else {
-        __pyx_t_5 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_6 = PyList_GET_ITEM(sequence, 1); 
+        __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_x, __pyx_t_6);
+        __pyx_t_6 = 0;
+        if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_8genexpr1__pyx_v_x))) __PYX_ERR(0, 161, __pyx_L6_error)
       }
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(__pyx_t_6);
-      #else
-      __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 146, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      #endif
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 146, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
-      index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_5);
-      index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_6);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
-      __pyx_t_8 = NULL;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      goto __pyx_L7_unpacking_done;
-      __pyx_L6_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __pyx_t_8 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(0, 146, __pyx_L1_error)
-      __pyx_L7_unpacking_done:;
-    }
-    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_i);
-    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_i, __pyx_t_5);
-    __Pyx_GIVEREF(__pyx_t_5);
-    __pyx_t_5 = 0;
-    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_m);
-    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_m, __pyx_t_6);
-    __Pyx_GIVEREF(__pyx_t_6);
-    __pyx_t_6 = 0;
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_6 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_i, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (!__pyx_t_10) {
-    } else {
-      __pyx_t_9 = __pyx_t_10;
-      goto __pyx_L9_bool_binop_done;
-    }
-    __pyx_t_6 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_m, __pyx_cur_scope->__pyx_v_i, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 146, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __pyx_t_9 = __pyx_t_10;
-    __pyx_L9_bool_binop_done:;
-    __pyx_t_10 = ((!__pyx_t_9) != 0);
-    if (__pyx_t_10) {
-      __Pyx_XDECREF(__pyx_r);
-      __Pyx_INCREF(Py_False);
-      __pyx_r = Py_False;
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      goto __pyx_L0;
-    }
-  }
-  /*else*/ {
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(Py_True);
-    __pyx_r = Py_True;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    goto __pyx_L0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_x); __pyx_8genexpr1__pyx_v_x = 0;
+      goto __pyx_L10_exit_scope;
+      __pyx_L6_error:;
+      __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_x); __pyx_8genexpr1__pyx_v_x = 0;
+      goto __pyx_L1_error;
+      __pyx_L10_exit_scope:;
+    } /* exit inner scope */
+    __pyx_v_imp_list = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+  __pyx_L3:;
 
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  #if !CYTHON_USE_EXC_INFO_STACK
-  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
-  #endif
-  __pyx_generator->resume_label = -1;
-  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
+  /* "cana/canalization/cboolean_canalization.pyx":163
+ *         imp_list = [x for x in implicant]
+ * 
+ *     n = len(imp_list)             # <<<<<<<<<<<<<<
+ *     if len(binstate_str) != n:
+ *         raise ValueError("Implicant and binstate must have the same length")
+ */
+  __pyx_t_4 = __Pyx_PyList_GET_SIZE(__pyx_v_imp_list); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 163, __pyx_L1_error)
+  __pyx_v_n = __pyx_t_4;
 
-/* "cana/canalization/cboolean_canalization.pyx":137
+  /* "cana/canalization/cboolean_canalization.pyx":164
  * 
+ *     n = len(imp_list)
+ *     if len(binstate_str) != n:             # <<<<<<<<<<<<<<
+ *         raise ValueError("Implicant and binstate must have the same length")
  * 
- * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
  */
+  if (unlikely(__pyx_v_binstate_str == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(0, 164, __pyx_L1_error)
+  }
+  __pyx_t_4 = __Pyx_PyUnicode_GET_LENGTH(__pyx_v_binstate_str); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 164, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_4 != __pyx_v_n);
+  if (unlikely(__pyx_t_2)) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":165
+ *     n = len(imp_list)
+ *     if len(binstate_str) != n:
+ *         raise ValueError("Implicant and binstate must have the same length")             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(n):
+ */
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __PYX_ERR(0, 165, __pyx_L1_error)
 
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_10__pi_covers(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, CYTHON_UNUSED PyObject *__pyx_v_binstate) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *__pyx_cur_scope;
-  PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_11__pi_covers_2generator = 0;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__pi_covers", 0);
-  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers, __pyx_empty_tuple, NULL);
-  if (unlikely(!__pyx_cur_scope)) {
-    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)Py_None);
-    __Pyx_INCREF(Py_None);
-    __PYX_ERR(0, 137, __pyx_L1_error)
-  } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+    /* "cana/canalization/cboolean_canalization.pyx":164
+ * 
+ *     n = len(imp_list)
+ *     if len(binstate_str) != n:             # <<<<<<<<<<<<<<
+ *         raise ValueError("Implicant and binstate must have the same length")
+ * 
+ */
   }
-  __pyx_cur_scope->__pyx_v_implicant = __pyx_v_implicant;
-  __Pyx_INCREF(__pyx_cur_scope->__pyx_v_implicant);
-  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_implicant);
 
-  /* "cana/canalization/cboolean_canalization.pyx":146
+  /* "cana/canalization/cboolean_canalization.pyx":167
+ *         raise ValueError("Implicant and binstate must have the same length")
  * 
- *     """
- *     return all(i == WILDCARD_SYMBOL or m == i for i, m in zip(implicant, input))             # <<<<<<<<<<<<<<
+ *     for i in range(n):             # <<<<<<<<<<<<<<
+ *         symbol = imp_list[i]
+ *         if symbol == binstate_str[i]:
+ */
+  __pyx_t_4 = __pyx_v_n;
+  __pyx_t_7 = __pyx_t_4;
+  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
+    __pyx_v_i = __pyx_t_8;
+
+    /* "cana/canalization/cboolean_canalization.pyx":168
  * 
+ *     for i in range(n):
+ *         symbol = imp_list[i]             # <<<<<<<<<<<<<<
+ *         if symbol == binstate_str[i]:
+ *             continue
+ */
+    __pyx_t_1 = PyList_GET_ITEM(__pyx_v_imp_list, __pyx_v_i);
+    __Pyx_INCREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_symbol, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":169
+ *     for i in range(n):
+ *         symbol = imp_list[i]
+ *         if symbol == binstate_str[i]:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if _is_wildcard_symbol(symbol):
+ */
+    __pyx_t_9 = __Pyx_GetItemInt_Unicode(__pyx_v_binstate_str, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 0, 0); if (unlikely(__pyx_t_9 == (Py_UCS4)-1)) __PYX_ERR(0, 169, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyUnicode_FromOrdinal(__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_symbol, __pyx_t_1, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 169, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (__pyx_t_2) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":170
+ *         symbol = imp_list[i]
+ *         if symbol == binstate_str[i]:
+ *             continue             # <<<<<<<<<<<<<<
+ *         if _is_wildcard_symbol(symbol):
+ *             continue
+ */
+      goto __pyx_L12_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":169
+ *     for i in range(n):
+ *         symbol = imp_list[i]
+ *         if symbol == binstate_str[i]:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if _is_wildcard_symbol(symbol):
+ */
+    }
+
+    /* "cana/canalization/cboolean_canalization.pyx":171
+ *         if symbol == binstate_str[i]:
+ *             continue
+ *         if _is_wildcard_symbol(symbol):             # <<<<<<<<<<<<<<
+ *             continue
+ *         return False
+ */
+    __pyx_t_2 = __pyx_f_4cana_12canalization_21cboolean_canalization__is_wildcard_symbol(__pyx_v_symbol); if (unlikely(__pyx_t_2 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L1_error)
+    if (__pyx_t_2) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":172
+ *             continue
+ *         if _is_wildcard_symbol(symbol):
+ *             continue             # <<<<<<<<<<<<<<
+ *         return False
+ *     return True
+ */
+      goto __pyx_L12_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":171
+ *         if symbol == binstate_str[i]:
+ *             continue
+ *         if _is_wildcard_symbol(symbol):             # <<<<<<<<<<<<<<
+ *             continue
+ *         return False
+ */
+    }
+
+    /* "cana/canalization/cboolean_canalization.pyx":173
+ *         if _is_wildcard_symbol(symbol):
+ *             continue
+ *         return False             # <<<<<<<<<<<<<<
+ *     return True
  * 
  */
-  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_pf_4cana_12canalization_21cboolean_canalization_11__pi_covers_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_Generator_Next(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
+    __pyx_r = 0;
+    goto __pyx_L0;
+    __pyx_L12_continue:;
+  }
 
-  /* "cana/canalization/cboolean_canalization.pyx":137
+  /* "cana/canalization/cboolean_canalization.pyx":174
+ *             continue
+ *         return False
+ *     return True             # <<<<<<<<<<<<<<
  * 
  * 
- * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
+ */
+  __pyx_r = 1;
+  goto __pyx_L0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint pi_covers_fast(object implicant, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage check for wildcard schemata."""
+ *     cdef list imp_list
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.__pi_covers", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.pi_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_gb_4cana_12canalization_21cboolean_canalization_11__pi_covers_2generator);
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF(__pyx_v_imp_list);
+  __Pyx_XDECREF(__pyx_v_symbol);
+  __Pyx_XDECREF(__pyx_v_binstate_str);
+  __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_x);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":149
- * 
- * 
- * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
- *     """
- *     Expand a wildcard schemata to list all binary states it covers.
- */
-
 /* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_wildcard_schemata(PyObject *__pyx_self, PyObject *__pyx_v_schemata); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_12expand_wildcard_schemata[] = "\n    Expand a wildcard schemata to list all binary states it covers.\n\n    Args:\n        schemata (string): the wildcard shemata\n    Returns:\n        binary_states (list): list of all binary states covered by the schemata\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_13expand_wildcard_schemata = {"expand_wildcard_schemata", (PyCFunction)__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_wildcard_schemata, METH_O, __pyx_doc_4cana_12canalization_21cboolean_canalization_12expand_wildcard_schemata};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_wildcard_schemata(PyObject *__pyx_self, PyObject *__pyx_v_schemata) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("expand_wildcard_schemata (wrapper)", 0);
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_wildcard_schemata(__pyx_self, ((PyObject *)__pyx_v_schemata));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_11pi_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_10pi_covers_fast, "Fast coverage check for wildcard schemata.");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_11pi_covers_fast = {"pi_covers_fast", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_11pi_covers_fast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_10pi_covers_fast};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_11pi_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_implicant = 0;
+  PyObject *__pyx_v_binstate = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("pi_covers_fast (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_implicant,&__pyx_n_s_binstate,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_implicant)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 151, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 151, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("pi_covers_fast", 1, 2, 2, 1); __PYX_ERR(0, 151, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "pi_covers_fast") < 0)) __PYX_ERR(0, 151, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+    }
+    __pyx_v_implicant = values[0];
+    __pyx_v_binstate = values[1];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("pi_covers_fast", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 151, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.pi_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_10pi_covers_fast(__pyx_self, __pyx_v_implicant, __pyx_v_binstate);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_wildcard_schemata(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_schemata) {
-  PyObject *__pyx_v_nwildcards = NULL;
-  PyObject *__pyx_v_binary_states = NULL;
-  PyObject *__pyx_v_wildstatenum = NULL;
-  PyObject *__pyx_v_wildstates = NULL;
-  PyObject *__pyx_v_wnum = NULL;
-  PyObject *__pyx_v_newstate = NULL;
-  PyObject *__pyx_v_b = NULL;
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_10pi_covers_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, PyObject *__pyx_v_binstate) {
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_1;
   PyObject *__pyx_t_2 = NULL;
-  PyObject *__pyx_t_3 = NULL;
-  PyObject *__pyx_t_4 = NULL;
-  int __pyx_t_5;
-  Py_ssize_t __pyx_t_6;
-  PyObject *(*__pyx_t_7)(PyObject *);
-  int __pyx_t_8;
-  PyObject *__pyx_t_9 = NULL;
-  Py_ssize_t __pyx_t_10;
-  PyObject *(*__pyx_t_11)(PyObject *);
-  int __pyx_t_12;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("expand_wildcard_schemata", 0);
-
-  /* "cana/canalization/cboolean_canalization.pyx":160
- * 
- *     # count the number of wildcard symbols
- *     nwildcards = schemata.count(WILDCARD_SYMBOL)             # <<<<<<<<<<<<<<
- * 
- *     # if there arent any symbols, return the original schemata
- */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_schemata, __pyx_n_s_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
+  __Pyx_RefNannySetupContext("pi_covers_fast", 1);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(__pyx_v_implicant, __pyx_v_binstate, 0); if (unlikely(__pyx_t_1 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 151, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 160, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_nwildcards = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":163
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.pi_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/canalization/cboolean_canalization.pyx":178
  * 
- *     # if there arent any symbols, return the original schemata
- *     if nwildcards == 0:             # <<<<<<<<<<<<<<
- *         return [schemata]
- *     else:
+ * @cython.cfunc
+ * cdef list _normalize_index_groups(object groups):             # <<<<<<<<<<<<<<
+ *     if not groups:
+ *         return []
  */
-  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_nwildcards, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 163, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__pyx_t_5) {
 
-    /* "cana/canalization/cboolean_canalization.pyx":164
- *     # if there arent any symbols, return the original schemata
- *     if nwildcards == 0:
- *         return [schemata]             # <<<<<<<<<<<<<<
- *     else:
- *         binary_states = []
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization__normalize_index_groups(PyObject *__pyx_v_groups) {
+  PyObject *__pyx_v_normalized = 0;
+  PyObject *__pyx_v_group = 0;
+  PyObject *__pyx_8genexpr2__pyx_v_idx = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  Py_ssize_t __pyx_t_9;
+  PyObject *(*__pyx_t_10)(PyObject *);
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_normalize_index_groups", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":179
+ * @cython.cfunc
+ * cdef list _normalize_index_groups(object groups):
+ *     if not groups:             # <<<<<<<<<<<<<<
+ *         return []
+ *     cdef list normalized = []
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_groups); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 179, __pyx_L1_error)
+  __pyx_t_2 = (!__pyx_t_1);
+  if (__pyx_t_2) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":180
+ * cdef list _normalize_index_groups(object groups):
+ *     if not groups:
+ *         return []             # <<<<<<<<<<<<<<
+ *     cdef list normalized = []
+ *     cdef object group
  */
     __Pyx_XDECREF(__pyx_r);
-    __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_INCREF(__pyx_v_schemata);
-    __Pyx_GIVEREF(__pyx_v_schemata);
-    PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_schemata);
-    __pyx_r = __pyx_t_1;
-    __pyx_t_1 = 0;
+    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 180, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_r = ((PyObject*)__pyx_t_3);
+    __pyx_t_3 = 0;
     goto __pyx_L0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":163
- * 
- *     # if there arent any symbols, return the original schemata
- *     if nwildcards == 0:             # <<<<<<<<<<<<<<
- *         return [schemata]
- *     else:
+    /* "cana/canalization/cboolean_canalization.pyx":179
+ * @cython.cfunc
+ * cdef list _normalize_index_groups(object groups):
+ *     if not groups:             # <<<<<<<<<<<<<<
+ *         return []
+ *     cdef list normalized = []
  */
   }
 
-  /* "cana/canalization/cboolean_canalization.pyx":166
- *         return [schemata]
- *     else:
- *         binary_states = []             # <<<<<<<<<<<<<<
- *         for wildstatenum in range(2**nwildcards):
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
+  /* "cana/canalization/cboolean_canalization.pyx":181
+ *     if not groups:
+ *         return []
+ *     cdef list normalized = []             # <<<<<<<<<<<<<<
+ *     cdef object group
+ *     cdef object idx
  */
-  /*else*/ {
-    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_v_binary_states = ((PyObject*)__pyx_t_1);
-    __pyx_t_1 = 0;
-
-    /* "cana/canalization/cboolean_canalization.pyx":167
- *     else:
- *         binary_states = []
- *         for wildstatenum in range(2**nwildcards):             # <<<<<<<<<<<<<<
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
- *             wnum = 0
+  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_v_normalized = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":184
+ *     cdef object group
+ *     cdef object idx
+ *     for group in groups:             # <<<<<<<<<<<<<<
+ *         if not group:
+ *             normalized.append([])
  */
-    __pyx_t_1 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_nwildcards, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
-      __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
-      __pyx_t_7 = NULL;
-    } else {
-      __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_7 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error)
-    }
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    for (;;) {
-      if (likely(!__pyx_t_7)) {
-        if (likely(PyList_CheckExact(__pyx_t_1))) {
-          if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 167, __pyx_L1_error)
-          #else
-          __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_2);
-          #endif
-        } else {
-          if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 167, __pyx_L1_error)
-          #else
-          __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_2);
+  if (likely(PyList_CheckExact(__pyx_v_groups)) || PyTuple_CheckExact(__pyx_v_groups)) {
+    __pyx_t_3 = __pyx_v_groups; __Pyx_INCREF(__pyx_t_3);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = NULL;
+  } else {
+    __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 184, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_5)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 184, __pyx_L1_error)
           #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
         }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 184, __pyx_L1_error)
+        #else
+        __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
       } else {
-        __pyx_t_2 = __pyx_t_7(__pyx_t_1);
-        if (unlikely(!__pyx_t_2)) {
-          PyObject* exc_type = PyErr_Occurred();
-          if (exc_type) {
-            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(0, 167, __pyx_L1_error)
-          }
-          break;
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 184, __pyx_L1_error)
+          #endif
+          if (__pyx_t_4 >= __pyx_temp) break;
         }
-        __Pyx_GOTREF(__pyx_t_2);
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 184, __pyx_L1_error)
+        #else
+        __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
       }
-      __Pyx_XDECREF_SET(__pyx_v_wildstatenum, __pyx_t_2);
-      __pyx_t_2 = 0;
-
-      /* "cana/canalization/cboolean_canalization.pyx":168
- *         binary_states = []
- *         for wildstatenum in range(2**nwildcards):
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)             # <<<<<<<<<<<<<<
- *             wnum = 0
- *             newstate = ''
- */
-      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_statenum_to_binstate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 168, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_4 = NULL;
-      __pyx_t_8 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
-        if (likely(__pyx_t_4)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-          __Pyx_INCREF(__pyx_t_4);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_3, function);
-          __pyx_t_8 = 1;
+    } else {
+      __pyx_t_6 = __pyx_t_5(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 184, __pyx_L1_error)
         }
+        break;
       }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_wildstatenum, __pyx_v_nwildcards};
-        __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_GOTREF(__pyx_t_2);
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_wildstatenum, __pyx_v_nwildcards};
-        __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-        __Pyx_GOTREF(__pyx_t_2);
-      } else
-      #endif
-      {
-        __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 168, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_9);
-        if (__pyx_t_4) {
-          __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); __pyx_t_4 = NULL;
-        }
-        __Pyx_INCREF(__pyx_v_wildstatenum);
-        __Pyx_GIVEREF(__pyx_v_wildstatenum);
-        PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_wildstatenum);
-        __Pyx_INCREF(__pyx_v_nwildcards);
-        __Pyx_GIVEREF(__pyx_v_nwildcards);
-        PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_nwildcards);
-        __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      }
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_XDECREF_SET(__pyx_v_wildstates, __pyx_t_2);
-      __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_group, __pyx_t_6);
+    __pyx_t_6 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":169
- *         for wildstatenum in range(2**nwildcards):
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
- *             wnum = 0             # <<<<<<<<<<<<<<
- *             newstate = ''
- *             for b in schemata:
+    /* "cana/canalization/cboolean_canalization.pyx":185
+ *     cdef object idx
+ *     for group in groups:
+ *         if not group:             # <<<<<<<<<<<<<<
+ *             normalized.append([])
+ *             continue
  */
-      __Pyx_INCREF(__pyx_int_0);
-      __Pyx_XDECREF_SET(__pyx_v_wnum, __pyx_int_0);
+    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_group); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 185, __pyx_L1_error)
+    __pyx_t_1 = (!__pyx_t_2);
+    if (__pyx_t_1) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":186
+ *     for group in groups:
+ *         if not group:
+ *             normalized.append([])             # <<<<<<<<<<<<<<
+ *             continue
+ *         normalized.append([int(idx) for idx in group])
+ */
+      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_normalized, __pyx_t_6); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 186, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":170
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
- *             wnum = 0
- *             newstate = ''             # <<<<<<<<<<<<<<
- *             for b in schemata:
- *                 if b == WILDCARD_SYMBOL:
+      /* "cana/canalization/cboolean_canalization.pyx":187
+ *         if not group:
+ *             normalized.append([])
+ *             continue             # <<<<<<<<<<<<<<
+ *         normalized.append([int(idx) for idx in group])
+ *     return normalized
  */
-      __Pyx_INCREF(__pyx_kp_s_);
-      __Pyx_XDECREF_SET(__pyx_v_newstate, __pyx_kp_s_);
+      goto __pyx_L4_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":185
+ *     cdef object idx
+ *     for group in groups:
+ *         if not group:             # <<<<<<<<<<<<<<
+ *             normalized.append([])
+ *             continue
+ */
+    }
 
-      /* "cana/canalization/cboolean_canalization.pyx":171
- *             wnum = 0
- *             newstate = ''
- *             for b in schemata:             # <<<<<<<<<<<<<<
- *                 if b == WILDCARD_SYMBOL:
- *                     newstate += wildstates[wnum]
+    /* "cana/canalization/cboolean_canalization.pyx":188
+ *             normalized.append([])
+ *             continue
+ *         normalized.append([int(idx) for idx in group])             # <<<<<<<<<<<<<<
+ *     return normalized
+ * 
  */
-      if (likely(PyList_CheckExact(__pyx_v_schemata)) || PyTuple_CheckExact(__pyx_v_schemata)) {
-        __pyx_t_2 = __pyx_v_schemata; __Pyx_INCREF(__pyx_t_2); __pyx_t_10 = 0;
-        __pyx_t_11 = NULL;
+    { /* enter inner scope */
+      __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 188, __pyx_L9_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (likely(PyList_CheckExact(__pyx_v_group)) || PyTuple_CheckExact(__pyx_v_group)) {
+        __pyx_t_8 = __pyx_v_group; __Pyx_INCREF(__pyx_t_8);
+        __pyx_t_9 = 0;
+        __pyx_t_10 = NULL;
       } else {
-        __pyx_t_10 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_schemata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 171, __pyx_L1_error)
+        __pyx_t_9 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_v_group); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 188, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 188, __pyx_L9_error)
       }
       for (;;) {
-        if (likely(!__pyx_t_11)) {
-          if (likely(PyList_CheckExact(__pyx_t_2))) {
-            if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        if (likely(!__pyx_t_10)) {
+          if (likely(PyList_CheckExact(__pyx_t_8))) {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_8);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 188, __pyx_L9_error)
+              #endif
+              if (__pyx_t_9 >= __pyx_temp) break;
+            }
             #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_10); __Pyx_INCREF(__pyx_t_3); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 171, __pyx_L1_error)
+            __pyx_t_11 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_11); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(0, 188, __pyx_L9_error)
             #else
-            __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 188, __pyx_L9_error)
+            __Pyx_GOTREF(__pyx_t_11);
             #endif
           } else {
-            if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_8);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 188, __pyx_L9_error)
+              #endif
+              if (__pyx_t_9 >= __pyx_temp) break;
+            }
             #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-            __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_10); __Pyx_INCREF(__pyx_t_3); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 171, __pyx_L1_error)
+            __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_11); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(0, 188, __pyx_L9_error)
             #else
-            __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 171, __pyx_L1_error)
-            __Pyx_GOTREF(__pyx_t_3);
+            __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 188, __pyx_L9_error)
+            __Pyx_GOTREF(__pyx_t_11);
             #endif
           }
         } else {
-          __pyx_t_3 = __pyx_t_11(__pyx_t_2);
-          if (unlikely(!__pyx_t_3)) {
+          __pyx_t_11 = __pyx_t_10(__pyx_t_8);
+          if (unlikely(!__pyx_t_11)) {
             PyObject* exc_type = PyErr_Occurred();
             if (exc_type) {
               if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-              else __PYX_ERR(0, 171, __pyx_L1_error)
+              else __PYX_ERR(0, 188, __pyx_L9_error)
             }
             break;
           }
-          __Pyx_GOTREF(__pyx_t_3);
-        }
-        __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_3);
-        __pyx_t_3 = 0;
-
-        /* "cana/canalization/cboolean_canalization.pyx":172
- *             newstate = ''
- *             for b in schemata:
- *                 if b == WILDCARD_SYMBOL:             # <<<<<<<<<<<<<<
- *                     newstate += wildstates[wnum]
- *                     wnum += 1
- */
-        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 172, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        __pyx_t_9 = PyObject_RichCompare(__pyx_v_b, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 172, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-        __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 172, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-        if (__pyx_t_5) {
-
-          /* "cana/canalization/cboolean_canalization.pyx":173
- *             for b in schemata:
- *                 if b == WILDCARD_SYMBOL:
- *                     newstate += wildstates[wnum]             # <<<<<<<<<<<<<<
- *                     wnum += 1
- *                 else:
- */
-          __pyx_t_9 = __Pyx_PyObject_GetItem(__pyx_v_wildstates, __pyx_v_wnum); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 173, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_9);
-          __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_newstate, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 173, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-          __Pyx_DECREF_SET(__pyx_v_newstate, __pyx_t_3);
-          __pyx_t_3 = 0;
-
-          /* "cana/canalization/cboolean_canalization.pyx":174
- *                 if b == WILDCARD_SYMBOL:
- *                     newstate += wildstates[wnum]
- *                     wnum += 1             # <<<<<<<<<<<<<<
- *                 else:
- *                     newstate += b
- */
-          __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_wnum, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 174, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          __Pyx_DECREF_SET(__pyx_v_wnum, __pyx_t_3);
-          __pyx_t_3 = 0;
-
-          /* "cana/canalization/cboolean_canalization.pyx":172
- *             newstate = ''
- *             for b in schemata:
- *                 if b == WILDCARD_SYMBOL:             # <<<<<<<<<<<<<<
- *                     newstate += wildstates[wnum]
- *                     wnum += 1
- */
-          goto __pyx_L8;
-        }
-
-        /* "cana/canalization/cboolean_canalization.pyx":176
- *                     wnum += 1
- *                 else:
- *                     newstate += b             # <<<<<<<<<<<<<<
- *             binary_states.append(newstate)
- *         return binary_states
- */
-        /*else*/ {
-          __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_newstate, __pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
-          __Pyx_DECREF_SET(__pyx_v_newstate, __pyx_t_3);
-          __pyx_t_3 = 0;
+          __Pyx_GOTREF(__pyx_t_11);
         }
-        __pyx_L8:;
-
-        /* "cana/canalization/cboolean_canalization.pyx":171
- *             wnum = 0
- *             newstate = ''
- *             for b in schemata:             # <<<<<<<<<<<<<<
- *                 if b == WILDCARD_SYMBOL:
- *                     newstate += wildstates[wnum]
- */
+        __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_idx, __pyx_t_11);
+        __pyx_t_11 = 0;
+        __pyx_t_11 = __Pyx_PyNumber_Int(__pyx_8genexpr2__pyx_v_idx); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 188, __pyx_L9_error)
+        __Pyx_GOTREF(__pyx_t_11);
+        if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_11))) __PYX_ERR(0, 188, __pyx_L9_error)
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
       }
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-      /* "cana/canalization/cboolean_canalization.pyx":177
- *                 else:
- *                     newstate += b
- *             binary_states.append(newstate)             # <<<<<<<<<<<<<<
- *         return binary_states
- * 
- */
-      __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_binary_states, __pyx_v_newstate); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 177, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_idx); __pyx_8genexpr2__pyx_v_idx = 0;
+      goto __pyx_L13_exit_scope;
+      __pyx_L9_error:;
+      __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_idx); __pyx_8genexpr2__pyx_v_idx = 0;
+      goto __pyx_L1_error;
+      __pyx_L13_exit_scope:;
+    } /* exit inner scope */
+    __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_normalized, __pyx_t_6); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 188, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":167
- *     else:
- *         binary_states = []
- *         for wildstatenum in range(2**nwildcards):             # <<<<<<<<<<<<<<
- *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
- *             wnum = 0
+    /* "cana/canalization/cboolean_canalization.pyx":184
+ *     cdef object group
+ *     cdef object idx
+ *     for group in groups:             # <<<<<<<<<<<<<<
+ *         if not group:
+ *             normalized.append([])
  */
-    }
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_L4_continue:;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":178
- *                     newstate += b
- *             binary_states.append(newstate)
- *         return binary_states             # <<<<<<<<<<<<<<
+  /* "cana/canalization/cboolean_canalization.pyx":189
+ *             continue
+ *         normalized.append([int(idx) for idx in group])
+ *     return normalized             # <<<<<<<<<<<<<<
  * 
  * 
  */
-    __Pyx_XDECREF(__pyx_r);
-    __Pyx_INCREF(__pyx_v_binary_states);
-    __pyx_r = __pyx_v_binary_states;
-    goto __pyx_L0;
-  }
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_normalized);
+  __pyx_r = __pyx_v_normalized;
+  goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":149
+  /* "cana/canalization/cboolean_canalization.pyx":178
  * 
- * 
- * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
- *     """
- *     Expand a wildcard schemata to list all binary states it covers.
+ * @cython.cfunc
+ * cdef list _normalize_index_groups(object groups):             # <<<<<<<<<<<<<<
+ *     if not groups:
+ *         return []
  */
 
   /* function exit code */
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_wildcard_schemata", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization._normalize_index_groups", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_nwildcards);
-  __Pyx_XDECREF(__pyx_v_binary_states);
-  __Pyx_XDECREF(__pyx_v_wildstatenum);
-  __Pyx_XDECREF(__pyx_v_wildstates);
-  __Pyx_XDECREF(__pyx_v_wnum);
-  __Pyx_XDECREF(__pyx_v_newstate);
-  __Pyx_XDECREF(__pyx_v_b);
+  __Pyx_XDECREF(__pyx_v_normalized);
+  __Pyx_XDECREF(__pyx_v_group);
+  __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_idx);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":181
- * 
- * 
- * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
+/* "cana/canalization/cboolean_canalization.pyx":193
  * 
+ * @cython.cfunc
+ * cdef list _init_implicant_stack(object two_symbol):             # <<<<<<<<<<<<<<
+ *     cdef list stack = []
+ *     cdef object item
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_15return_pi_coverage(PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_14return_pi_coverage[] = "Computes the binary states coverage by Prime Implicant schematas.\n\n    Args:\n        prime_implicants (set): a set of prime implicants.\n            This is returned by `find_implicants_qm`.\n    Returns:\n        pi_coverage (dict) : a dictionary of coverage where keys are input states and values are lists of the Prime Implicants covering that input.\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_15return_pi_coverage = {"return_pi_coverage", (PyCFunction)__pyx_pw_4cana_12canalization_21cboolean_canalization_15return_pi_coverage, METH_O, __pyx_doc_4cana_12canalization_21cboolean_canalization_14return_pi_coverage};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_15return_pi_coverage(PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants) {
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("return_pi_coverage (wrapper)", 0);
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_14return_pi_coverage(__pyx_self, ((PyObject *)__pyx_v_prime_implicants));
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_14return_pi_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants) {
-  PyObject *__pyx_v_pi_coverage = NULL;
-  PyObject *__pyx_v_pi = NULL;
-  PyObject *__pyx_v_binstate = NULL;
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization__init_implicant_stack(PyObject *__pyx_v_two_symbol) {
+  PyObject *__pyx_v_stack = 0;
+  PyObject *__pyx_v_item = 0;
+  PyObject *__pyx_8genexpr3__pyx_v_c = NULL;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  Py_ssize_t __pyx_t_2;
-  PyObject *(*__pyx_t_3)(PyObject *);
-  PyObject *__pyx_t_4 = NULL;
-  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *(*__pyx_t_5)(PyObject *);
   PyObject *__pyx_t_6 = NULL;
-  Py_ssize_t __pyx_t_7;
-  PyObject *(*__pyx_t_8)(PyObject *);
-  int __pyx_t_9;
-  int __pyx_t_10;
-  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  Py_ssize_t __pyx_t_8;
+  PyObject *(*__pyx_t_9)(PyObject *);
+  PyObject *__pyx_t_10 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("return_pi_coverage", 0);
-
-  /* "cana/canalization/cboolean_canalization.pyx":191
- *     """
- * 
- *     pi_coverage = dict()             # <<<<<<<<<<<<<<
- *     for pi in prime_implicants:
- *         for binstate in expand_wildcard_schemata(pi):
+  __Pyx_RefNannySetupContext("_init_implicant_stack", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":194
+ * @cython.cfunc
+ * cdef list _init_implicant_stack(object two_symbol):
+ *     cdef list stack = []             # <<<<<<<<<<<<<<
+ *     cdef object item
+ *     if isinstance(two_symbol, str):
  */
-  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 194, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_v_pi_coverage = ((PyObject*)__pyx_t_1);
+  __pyx_v_stack = ((PyObject*)__pyx_t_1);
   __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":192
- * 
- *     pi_coverage = dict()
- *     for pi in prime_implicants:             # <<<<<<<<<<<<<<
- *         for binstate in expand_wildcard_schemata(pi):
- *             if binstate not in pi_coverage:
+  /* "cana/canalization/cboolean_canalization.pyx":196
+ *     cdef list stack = []
+ *     cdef object item
+ *     if isinstance(two_symbol, str):             # <<<<<<<<<<<<<<
+ *         stack.append(list(two_symbol))
+ *     else:
  */
-  if (likely(PyList_CheckExact(__pyx_v_prime_implicants)) || PyTuple_CheckExact(__pyx_v_prime_implicants)) {
-    __pyx_t_1 = __pyx_v_prime_implicants; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
-    __pyx_t_3 = NULL;
-  } else {
-    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_prime_implicants); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __pyx_t_2 = PyUnicode_Check(__pyx_v_two_symbol); 
+  if (__pyx_t_2) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":197
+ *     cdef object item
+ *     if isinstance(two_symbol, str):
+ *         stack.append(list(two_symbol))             # <<<<<<<<<<<<<<
+ *     else:
+ *         for item in two_symbol:
+ */
+    __pyx_t_1 = PySequence_List(__pyx_v_two_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 197, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 192, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_stack, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 197, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":196
+ *     cdef list stack = []
+ *     cdef object item
+ *     if isinstance(two_symbol, str):             # <<<<<<<<<<<<<<
+ *         stack.append(list(two_symbol))
+ *     else:
+ */
+    goto __pyx_L3;
   }
-  for (;;) {
-    if (likely(!__pyx_t_3)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 192, __pyx_L1_error)
-        #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        #endif
-      } else {
-        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 192, __pyx_L1_error)
-        #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 192, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        #endif
-      }
-    } else {
-      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
-      if (unlikely(!__pyx_t_4)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 192, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_4);
-    }
-    __Pyx_XDECREF_SET(__pyx_v_pi, __pyx_t_4);
-    __pyx_t_4 = 0;
 
-    /* "cana/canalization/cboolean_canalization.pyx":193
- *     pi_coverage = dict()
- *     for pi in prime_implicants:
- *         for binstate in expand_wildcard_schemata(pi):             # <<<<<<<<<<<<<<
- *             if binstate not in pi_coverage:
- *                 pi_coverage[binstate] = set()
+  /* "cana/canalization/cboolean_canalization.pyx":199
+ *         stack.append(list(two_symbol))
+ *     else:
+ *         for item in two_symbol:             # <<<<<<<<<<<<<<
+ *             if isinstance(item, str):
+ *                 stack.append(list(item))
  */
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_expand_wildcard_schemata); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
-      if (likely(__pyx_t_6)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-        __Pyx_INCREF(__pyx_t_6);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_5, function);
-      }
-    }
-    __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_v_pi) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_pi);
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 193, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
-      __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_7 = 0;
-      __pyx_t_8 = NULL;
+  /*else*/ {
+    if (likely(PyList_CheckExact(__pyx_v_two_symbol)) || PyTuple_CheckExact(__pyx_v_two_symbol)) {
+      __pyx_t_1 = __pyx_v_two_symbol; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_4 = 0;
+      __pyx_t_5 = NULL;
     } else {
-      __pyx_t_7 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 193, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __pyx_t_8 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 193, __pyx_L1_error)
+      __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_two_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 199, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 199, __pyx_L1_error)
     }
-    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
     for (;;) {
-      if (likely(!__pyx_t_8)) {
-        if (likely(PyList_CheckExact(__pyx_t_5))) {
-          if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_5)) break;
+      if (likely(!__pyx_t_5)) {
+        if (likely(PyList_CheckExact(__pyx_t_1))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 193, __pyx_L1_error)
+          __pyx_t_6 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 199, __pyx_L1_error)
           #else
-          __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 193, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_4);
+          __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_6);
           #endif
         } else {
-          if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 199, __pyx_L1_error)
+            #endif
+            if (__pyx_t_4 >= __pyx_temp) break;
+          }
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 193, __pyx_L1_error)
+          __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(0, 199, __pyx_L1_error)
           #else
-          __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 193, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_4);
+          __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 199, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_6);
           #endif
         }
       } else {
-        __pyx_t_4 = __pyx_t_8(__pyx_t_5);
-        if (unlikely(!__pyx_t_4)) {
+        __pyx_t_6 = __pyx_t_5(__pyx_t_1);
+        if (unlikely(!__pyx_t_6)) {
           PyObject* exc_type = PyErr_Occurred();
           if (exc_type) {
             if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-            else __PYX_ERR(0, 193, __pyx_L1_error)
+            else __PYX_ERR(0, 199, __pyx_L1_error)
           }
           break;
         }
-        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GOTREF(__pyx_t_6);
       }
-      __Pyx_XDECREF_SET(__pyx_v_binstate, __pyx_t_4);
-      __pyx_t_4 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_6);
+      __pyx_t_6 = 0;
 
-      /* "cana/canalization/cboolean_canalization.pyx":194
- *     for pi in prime_implicants:
- *         for binstate in expand_wildcard_schemata(pi):
- *             if binstate not in pi_coverage:             # <<<<<<<<<<<<<<
- *                 pi_coverage[binstate] = set()
- *             pi_coverage[binstate].add(pi)
+      /* "cana/canalization/cboolean_canalization.pyx":200
+ *     else:
+ *         for item in two_symbol:
+ *             if isinstance(item, str):             # <<<<<<<<<<<<<<
+ *                 stack.append(list(item))
+ *             else:
  */
-      __pyx_t_9 = (__Pyx_PyDict_ContainsTF(__pyx_v_binstate, __pyx_v_pi_coverage, Py_NE)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 194, __pyx_L1_error)
-      __pyx_t_10 = (__pyx_t_9 != 0);
-      if (__pyx_t_10) {
-
-        /* "cana/canalization/cboolean_canalization.pyx":195
- *         for binstate in expand_wildcard_schemata(pi):
- *             if binstate not in pi_coverage:
- *                 pi_coverage[binstate] = set()             # <<<<<<<<<<<<<<
- *             pi_coverage[binstate].add(pi)
- * 
+      __pyx_t_2 = PyUnicode_Check(__pyx_v_item); 
+      if (__pyx_t_2) {
+
+        /* "cana/canalization/cboolean_canalization.pyx":201
+ *         for item in two_symbol:
+ *             if isinstance(item, str):
+ *                 stack.append(list(item))             # <<<<<<<<<<<<<<
+ *             else:
+ *                 stack.append([c for c in item])
  */
-        __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 195, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        if (unlikely(PyDict_SetItem(__pyx_v_pi_coverage, __pyx_v_binstate, __pyx_t_4) < 0)) __PYX_ERR(0, 195, __pyx_L1_error)
-        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __pyx_t_6 = PySequence_List(__pyx_v_item); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 201, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_stack, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 201, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
 
-        /* "cana/canalization/cboolean_canalization.pyx":194
- *     for pi in prime_implicants:
- *         for binstate in expand_wildcard_schemata(pi):
- *             if binstate not in pi_coverage:             # <<<<<<<<<<<<<<
- *                 pi_coverage[binstate] = set()
- *             pi_coverage[binstate].add(pi)
+        /* "cana/canalization/cboolean_canalization.pyx":200
+ *     else:
+ *         for item in two_symbol:
+ *             if isinstance(item, str):             # <<<<<<<<<<<<<<
+ *                 stack.append(list(item))
+ *             else:
  */
+        goto __pyx_L6;
       }
 
-      /* "cana/canalization/cboolean_canalization.pyx":196
- *             if binstate not in pi_coverage:
- *                 pi_coverage[binstate] = set()
- *             pi_coverage[binstate].add(pi)             # <<<<<<<<<<<<<<
+      /* "cana/canalization/cboolean_canalization.pyx":203
+ *                 stack.append(list(item))
+ *             else:
+ *                 stack.append([c for c in item])             # <<<<<<<<<<<<<<
+ *     return stack
  * 
- *     return pi_coverage
  */
-      __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_pi_coverage, __pyx_v_binstate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 196, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_add); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 196, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __pyx_t_6 = NULL;
-      if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
-        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11);
-        if (likely(__pyx_t_6)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
-          __Pyx_INCREF(__pyx_t_6);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_11, function);
-        }
+      /*else*/ {
+        { /* enter inner scope */
+          __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 203, __pyx_L9_error)
+          __Pyx_GOTREF(__pyx_t_6);
+          if (likely(PyList_CheckExact(__pyx_v_item)) || PyTuple_CheckExact(__pyx_v_item)) {
+            __pyx_t_7 = __pyx_v_item; __Pyx_INCREF(__pyx_t_7);
+            __pyx_t_8 = 0;
+            __pyx_t_9 = NULL;
+          } else {
+            __pyx_t_8 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_item); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 203, __pyx_L9_error)
+            __Pyx_GOTREF(__pyx_t_7);
+            __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 203, __pyx_L9_error)
+          }
+          for (;;) {
+            if (likely(!__pyx_t_9)) {
+              if (likely(PyList_CheckExact(__pyx_t_7))) {
+                {
+                  Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7);
+                  #if !CYTHON_ASSUME_SAFE_MACROS
+                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 203, __pyx_L9_error)
+                  #endif
+                  if (__pyx_t_8 >= __pyx_temp) break;
+                }
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                __pyx_t_10 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_8); __Pyx_INCREF(__pyx_t_10); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 203, __pyx_L9_error)
+                #else
+                __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 203, __pyx_L9_error)
+                __Pyx_GOTREF(__pyx_t_10);
+                #endif
+              } else {
+                {
+                  Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7);
+                  #if !CYTHON_ASSUME_SAFE_MACROS
+                  if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 203, __pyx_L9_error)
+                  #endif
+                  if (__pyx_t_8 >= __pyx_temp) break;
+                }
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_8); __Pyx_INCREF(__pyx_t_10); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 203, __pyx_L9_error)
+                #else
+                __pyx_t_10 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 203, __pyx_L9_error)
+                __Pyx_GOTREF(__pyx_t_10);
+                #endif
+              }
+            } else {
+              __pyx_t_10 = __pyx_t_9(__pyx_t_7);
+              if (unlikely(!__pyx_t_10)) {
+                PyObject* exc_type = PyErr_Occurred();
+                if (exc_type) {
+                  if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+                  else __PYX_ERR(0, 203, __pyx_L9_error)
+                }
+                break;
+              }
+              __Pyx_GOTREF(__pyx_t_10);
+            }
+            __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_c, __pyx_t_10);
+            __pyx_t_10 = 0;
+            if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_8genexpr3__pyx_v_c))) __PYX_ERR(0, 203, __pyx_L9_error)
+          }
+          __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+          __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c); __pyx_8genexpr3__pyx_v_c = 0;
+          goto __pyx_L13_exit_scope;
+          __pyx_L9_error:;
+          __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c); __pyx_8genexpr3__pyx_v_c = 0;
+          goto __pyx_L1_error;
+          __pyx_L13_exit_scope:;
+        } /* exit inner scope */
+        __pyx_t_3 = __Pyx_PyList_Append(__pyx_v_stack, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 203, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
       }
-      __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_6, __pyx_v_pi) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_pi);
-      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_4);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_L6:;
 
-      /* "cana/canalization/cboolean_canalization.pyx":193
- *     pi_coverage = dict()
- *     for pi in prime_implicants:
- *         for binstate in expand_wildcard_schemata(pi):             # <<<<<<<<<<<<<<
- *             if binstate not in pi_coverage:
- *                 pi_coverage[binstate] = set()
+      /* "cana/canalization/cboolean_canalization.pyx":199
+ *         stack.append(list(two_symbol))
+ *     else:
+ *         for item in two_symbol:             # <<<<<<<<<<<<<<
+ *             if isinstance(item, str):
+ *                 stack.append(list(item))
  */
     }
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-
-    /* "cana/canalization/cboolean_canalization.pyx":192
- * 
- *     pi_coverage = dict()
- *     for pi in prime_implicants:             # <<<<<<<<<<<<<<
- *         for binstate in expand_wildcard_schemata(pi):
- *             if binstate not in pi_coverage:
- */
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_L3:;
 
-  /* "cana/canalization/cboolean_canalization.pyx":198
- *             pi_coverage[binstate].add(pi)
- * 
- *     return pi_coverage             # <<<<<<<<<<<<<<
+  /* "cana/canalization/cboolean_canalization.pyx":204
+ *             else:
+ *                 stack.append([c for c in item])
+ *     return stack             # <<<<<<<<<<<<<<
  * 
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_pi_coverage);
-  __pyx_r = __pyx_v_pi_coverage;
+  __Pyx_INCREF(__pyx_v_stack);
+  __pyx_r = __pyx_v_stack;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":181
- * 
- * 
- * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
+  /* "cana/canalization/cboolean_canalization.pyx":193
  * 
+ * @cython.cfunc
+ * cdef list _init_implicant_stack(object two_symbol):             # <<<<<<<<<<<<<<
+ *     cdef list stack = []
+ *     cdef object item
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
   __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.return_pi_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization._init_implicant_stack", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_pi_coverage);
-  __Pyx_XDECREF(__pyx_v_pi);
-  __Pyx_XDECREF(__pyx_v_binstate);
+  __Pyx_XDECREF(__pyx_v_stack);
+  __Pyx_XDECREF(__pyx_v_item);
+  __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":201
- * 
- * 
- * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
+/* "cana/canalization/cboolean_canalization.pyx":208
  * 
+ * @cython.cfunc
+ * cdef void _permute_assign(             # <<<<<<<<<<<<<<
+ *     list base_implicant,
+ *     list idxs,
  */
 
-/* Python wrapper */
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_17input_wildcard_coverage(PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage); /*proto*/
-static char __pyx_doc_4cana_12canalization_21cboolean_canalization_16input_wildcard_coverage[] = "Computes the binary states coverage by Prime Implicant schematas.\n\n    Args:\n        pi_coverage (dict): a dict mapping binary states to their prime implicants.\n            This is returned by `return_pi_coverage`.\n    Returns:\n        input_wildcard_coverage (dict) : a dictionary of coverage where keys are inputs and values are lists of wither a WildCard covers that input.\n\n    ";
-static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_17input_wildcard_coverage = {"input_wildcard_coverage", (PyCFunction)__pyx_pw_4cana_12canalization_21cboolean_canalization_17input_wildcard_coverage, METH_O, __pyx_doc_4cana_12canalization_21cboolean_canalization_16input_wildcard_coverage};
-static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_17input_wildcard_coverage(PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage) {
-  PyObject *__pyx_r = 0;
+static void __pyx_f_4cana_12canalization_21cboolean_canalization__permute_assign(PyObject *__pyx_v_base_implicant, PyObject *__pyx_v_idxs, PyObject *__pyx_v_chars, Py_ssize_t __pyx_v_pos, Py_ssize_t __pyx_v_n, PyObject *__pyx_v_stack, PyObject *__pyx_v_seen) {
+  Py_ssize_t __pyx_v_i;
+  PyObject *__pyx_v_tmp = 0;
+  PyObject *__pyx_v_used = 0;
+  PyObject *__pyx_v_new_implicant = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("input_wildcard_coverage (wrapper)", 0);
-  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_16input_wildcard_coverage(__pyx_self, ((PyObject *)__pyx_v_pi_coverage));
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_permute_assign", 1);
 
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+  /* "cana/canalization/cboolean_canalization.pyx":221
+ *     cdef dict used
+ * 
+ *     if pos == n:             # <<<<<<<<<<<<<<
+ *         new_implicant = base_implicant[:]
+ *         for i in range(n):
+ */
+  __pyx_t_1 = (__pyx_v_pos == __pyx_v_n);
+  if (__pyx_t_1) {
 
-/* "cana/canalization/cboolean_canalization.pyx":217
- *     for binstate, piset in pi_coverage.items():
- *         for i in range(k):
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)             # <<<<<<<<<<<<<<
+    /* "cana/canalization/cboolean_canalization.pyx":222
  * 
- *     return input_to_wildcards
+ *     if pos == n:
+ *         new_implicant = base_implicant[:]             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             new_implicant[idxs[i]] = chars[i]
+ */
+    if (unlikely(__pyx_v_base_implicant == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 222, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_PyList_GetSlice(__pyx_v_base_implicant, 0, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_new_implicant = ((PyObject*)__pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":223
+ *     if pos == n:
+ *         new_implicant = base_implicant[:]
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             new_implicant[idxs[i]] = chars[i]
+ *         tmp = tuple(new_implicant)
  */
+    __pyx_t_3 = __pyx_v_n;
+    __pyx_t_4 = __pyx_t_3;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "cana/canalization/cboolean_canalization.pyx":224
+ *         new_implicant = base_implicant[:]
+ *         for i in range(n):
+ *             new_implicant[idxs[i]] = chars[i]             # <<<<<<<<<<<<<<
+ *         tmp = tuple(new_implicant)
+ *         if tmp not in seen:
+ */
+      if (unlikely(__pyx_v_chars == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 224, __pyx_L1_error)
+      }
+      __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      if (unlikely(__pyx_v_idxs == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 224, __pyx_L1_error)
+      }
+      __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_idxs, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 224, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (unlikely((PyObject_SetItem(__pyx_v_new_implicant, __pyx_t_6, __pyx_t_2) < 0))) __PYX_ERR(0, 224, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
 
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(PyObject *__pyx_self) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *__pyx_cur_scope;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("genexpr", 0);
-  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr, __pyx_empty_tuple, NULL);
-  if (unlikely(!__pyx_cur_scope)) {
-    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)Py_None);
-    __Pyx_INCREF(Py_None);
-    __PYX_ERR(0, 217, __pyx_L1_error)
-  } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+    /* "cana/canalization/cboolean_canalization.pyx":225
+ *         for i in range(n):
+ *             new_implicant[idxs[i]] = chars[i]
+ *         tmp = tuple(new_implicant)             # <<<<<<<<<<<<<<
+ *         if tmp not in seen:
+ *             stack.append(new_implicant)
+ */
+    __pyx_t_2 = PyList_AsTuple(__pyx_v_new_implicant); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_v_tmp = __pyx_t_2;
+    __pyx_t_2 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":226
+ *             new_implicant[idxs[i]] = chars[i]
+ *         tmp = tuple(new_implicant)
+ *         if tmp not in seen:             # <<<<<<<<<<<<<<
+ *             stack.append(new_implicant)
+ *         return
+ */
+    if (unlikely(__pyx_v_seen == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 226, __pyx_L1_error)
+    }
+    __pyx_t_1 = (__Pyx_PySet_ContainsTF(__pyx_v_tmp, __pyx_v_seen, Py_NE)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 226, __pyx_L1_error)
+    if (__pyx_t_1) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":227
+ *         tmp = tuple(new_implicant)
+ *         if tmp not in seen:
+ *             stack.append(new_implicant)             # <<<<<<<<<<<<<<
+ *         return
+ * 
+ */
+      if (unlikely(__pyx_v_stack == Py_None)) {
+        PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append");
+        __PYX_ERR(0, 227, __pyx_L1_error)
+      }
+      __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_stack, __pyx_v_new_implicant); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 227, __pyx_L1_error)
+
+      /* "cana/canalization/cboolean_canalization.pyx":226
+ *             new_implicant[idxs[i]] = chars[i]
+ *         tmp = tuple(new_implicant)
+ *         if tmp not in seen:             # <<<<<<<<<<<<<<
+ *             stack.append(new_implicant)
+ *         return
+ */
+    }
+
+    /* "cana/canalization/cboolean_canalization.pyx":228
+ *         if tmp not in seen:
+ *             stack.append(new_implicant)
+ *         return             # <<<<<<<<<<<<<<
+ * 
+ *     used = {}
+ */
+    goto __pyx_L0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":221
+ *     cdef dict used
+ * 
+ *     if pos == n:             # <<<<<<<<<<<<<<
+ *         new_implicant = base_implicant[:]
+ *         for i in range(n):
+ */
   }
-  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *) __pyx_self;
-  __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
-  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
-  {
-    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_input_wildcard_coverage_locals_g, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!gen)) __PYX_ERR(0, 217, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_cur_scope);
-    __Pyx_RefNannyFinishContext();
-    return (PyObject *) gen;
+
+  /* "cana/canalization/cboolean_canalization.pyx":230
+ *         return
+ * 
+ *     used = {}             # <<<<<<<<<<<<<<
+ *     for i in range(pos, n):
+ *         tmp = chars[i]
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_used = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":231
+ * 
+ *     used = {}
+ *     for i in range(pos, n):             # <<<<<<<<<<<<<<
+ *         tmp = chars[i]
+ *         if tmp in used:
+ */
+  __pyx_t_3 = __pyx_v_n;
+  __pyx_t_4 = __pyx_t_3;
+  for (__pyx_t_5 = __pyx_v_pos; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+    __pyx_v_i = __pyx_t_5;
+
+    /* "cana/canalization/cboolean_canalization.pyx":232
+ *     used = {}
+ *     for i in range(pos, n):
+ *         tmp = chars[i]             # <<<<<<<<<<<<<<
+ *         if tmp in used:
+ *             continue
+ */
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 232, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_tmp, __pyx_t_2);
+    __pyx_t_2 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":233
+ *     for i in range(pos, n):
+ *         tmp = chars[i]
+ *         if tmp in used:             # <<<<<<<<<<<<<<
+ *             continue
+ *         used[tmp] = None
+ */
+    __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_v_tmp, __pyx_v_used, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 233, __pyx_L1_error)
+    if (__pyx_t_1) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":234
+ *         tmp = chars[i]
+ *         if tmp in used:
+ *             continue             # <<<<<<<<<<<<<<
+ *         used[tmp] = None
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ */
+      goto __pyx_L7_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":233
+ *     for i in range(pos, n):
+ *         tmp = chars[i]
+ *         if tmp in used:             # <<<<<<<<<<<<<<
+ *             continue
+ *         used[tmp] = None
+ */
+    }
+
+    /* "cana/canalization/cboolean_canalization.pyx":235
+ *         if tmp in used:
+ *             continue
+ *         used[tmp] = None             # <<<<<<<<<<<<<<
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ *         _permute_assign(base_implicant, idxs, chars, pos + 1, n, stack, seen)
+ */
+    if (unlikely((PyDict_SetItem(__pyx_v_used, __pyx_v_tmp, Py_None) < 0))) __PYX_ERR(0, 235, __pyx_L1_error)
+
+    /* "cana/canalization/cboolean_canalization.pyx":236
+ *             continue
+ *         used[tmp] = None
+ *         chars[pos], chars[i] = chars[i], chars[pos]             # <<<<<<<<<<<<<<
+ *         _permute_assign(base_implicant, idxs, chars, pos + 1, n, stack, seen)
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ */
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 236, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 236, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_pos, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 236, __pyx_L1_error)
+    }
+    if (unlikely((__Pyx_SetItemInt(__pyx_v_chars, __pyx_v_pos, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 236, __pyx_L1_error)
+    }
+    if (unlikely((__Pyx_SetItemInt(__pyx_v_chars, __pyx_v_i, __pyx_t_6, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(0, 236, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":237
+ *         used[tmp] = None
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ *         _permute_assign(base_implicant, idxs, chars, pos + 1, n, stack, seen)             # <<<<<<<<<<<<<<
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ * 
+ */
+    __pyx_f_4cana_12canalization_21cboolean_canalization__permute_assign(__pyx_v_base_implicant, __pyx_v_idxs, __pyx_v_chars, (__pyx_v_pos + 1), __pyx_v_n, __pyx_v_stack, __pyx_v_seen); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 237, __pyx_L1_error)
+
+    /* "cana/canalization/cboolean_canalization.pyx":238
+ *         chars[pos], chars[i] = chars[i], chars[pos]
+ *         _permute_assign(base_implicant, idxs, chars, pos + 1, n, stack, seen)
+ *         chars[pos], chars[i] = chars[i], chars[pos]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 238, __pyx_L1_error)
+    }
+    __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 238, __pyx_L1_error)
+    }
+    __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_chars, __pyx_v_pos, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 238, __pyx_L1_error)
+    }
+    if (unlikely((__Pyx_SetItemInt(__pyx_v_chars, __pyx_v_pos, __pyx_t_6, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    if (unlikely(__pyx_v_chars == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(0, 238, __pyx_L1_error)
+    }
+    if (unlikely((__Pyx_SetItemInt(__pyx_v_chars, __pyx_v_i, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(0, 238, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_L7_continue:;
   }
 
+  /* "cana/canalization/cboolean_canalization.pyx":208
+ * 
+ * @cython.cfunc
+ * cdef void _permute_assign(             # <<<<<<<<<<<<<<
+ *     list base_implicant,
+ *     list idxs,
+ */
+
   /* function exit code */
+  goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.input_wildcard_coverage.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
-  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization._permute_assign", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_tmp);
+  __Pyx_XDECREF(__pyx_v_used);
+  __Pyx_XDECREF(__pyx_v_new_implicant);
   __Pyx_RefNannyFinishContext();
-  return __pyx_r;
 }
 
-static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
-{
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *__pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)__pyx_generator->closure);
-  PyObject *__pyx_r = NULL;
-  PyObject *__pyx_t_1 = NULL;
-  Py_ssize_t __pyx_t_2;
-  PyObject *(*__pyx_t_3)(PyObject *);
+/* "cana/canalization/cboolean_canalization.pyx":242
+ * 
+ * @cython.cfunc
+ * cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t n = len(idxs)
+ *     if n <= 1:
+ */
+
+static void __pyx_f_4cana_12canalization_21cboolean_canalization__enqueue_permutations(PyObject *__pyx_v_base_implicant, PyObject *__pyx_v_idxs, PyObject *__pyx_v_stack, PyObject *__pyx_v_seen) {
+  Py_ssize_t __pyx_v_n;
+  PyObject *__pyx_v_chars = NULL;
+  PyObject *__pyx_8genexpr4__pyx_v_i = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
   PyObject *__pyx_t_4 = NULL;
   PyObject *__pyx_t_5 = NULL;
-  PyObject *__pyx_t_6 = NULL;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("genexpr", 0);
-  switch (__pyx_generator->resume_label) {
-    case 0: goto __pyx_L3_first_run;
-    case 1: goto __pyx_L6_resume_from_yield;
-    default: /* CPython raises the right error here */
-    __Pyx_RefNannyFinishContext();
-    return NULL;
+  __Pyx_RefNannySetupContext("_enqueue_permutations", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":243
+ * @cython.cfunc
+ * cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):
+ *     cdef Py_ssize_t n = len(idxs)             # <<<<<<<<<<<<<<
+ *     if n <= 1:
+ *         return
+ */
+  if (unlikely(__pyx_v_idxs == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
+    __PYX_ERR(0, 243, __pyx_L1_error)
   }
-  __pyx_L3_first_run:;
-  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 217, __pyx_L1_error)
-  if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_piset)) { __Pyx_RaiseClosureNameError("piset"); __PYX_ERR(0, 217, __pyx_L1_error) }
-  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_piset)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_piset)) {
-    __pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_piset; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
-    __pyx_t_3 = NULL;
-  } else {
-    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_piset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyList_GET_SIZE(__pyx_v_idxs); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 243, __pyx_L1_error)
+  __pyx_v_n = __pyx_t_1;
+
+  /* "cana/canalization/cboolean_canalization.pyx":244
+ * cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):
+ *     cdef Py_ssize_t n = len(idxs)
+ *     if n <= 1:             # <<<<<<<<<<<<<<
+ *         return
+ *     chars = [base_implicant[i] for i in idxs]
+ */
+  __pyx_t_2 = (__pyx_v_n <= 1);
+  if (__pyx_t_2) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":245
+ *     cdef Py_ssize_t n = len(idxs)
+ *     if n <= 1:
+ *         return             # <<<<<<<<<<<<<<
+ *     chars = [base_implicant[i] for i in idxs]
+ *     _permute_assign(base_implicant, idxs, chars, 0, n, stack, seen)
+ */
+    goto __pyx_L0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":244
+ * cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):
+ *     cdef Py_ssize_t n = len(idxs)
+ *     if n <= 1:             # <<<<<<<<<<<<<<
+ *         return
+ *     chars = [base_implicant[i] for i in idxs]
+ */
   }
-  for (;;) {
-    if (likely(!__pyx_t_3)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 217, __pyx_L1_error)
-        #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
-        #endif
-      } else {
-        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 217, __pyx_L1_error)
-        #else
-        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_4);
+
+  /* "cana/canalization/cboolean_canalization.pyx":246
+ *     if n <= 1:
+ *         return
+ *     chars = [base_implicant[i] for i in idxs]             # <<<<<<<<<<<<<<
+ *     _permute_assign(base_implicant, idxs, chars, 0, n, stack, seen)
+ * 
+ */
+  { /* enter inner scope */
+    __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L6_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (unlikely(__pyx_v_idxs == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 246, __pyx_L6_error)
+    }
+    __pyx_t_4 = __pyx_v_idxs; __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_1 = 0;
+    for (;;) {
+      {
+        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 246, __pyx_L6_error)
         #endif
+        if (__pyx_t_1 >= __pyx_temp) break;
       }
-    } else {
-      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
-      if (unlikely(!__pyx_t_4)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 217, __pyx_L1_error)
-        }
-        break;
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 246, __pyx_L6_error)
+      #else
+      __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      #endif
+      __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_i, __pyx_t_5);
+      __pyx_t_5 = 0;
+      if (unlikely(__pyx_v_base_implicant == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 246, __pyx_L6_error)
       }
-      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_base_implicant, __pyx_8genexpr4__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L6_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 246, __pyx_L6_error)
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
     }
-    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_pi);
-    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_pi, __pyx_t_4);
-    __Pyx_GIVEREF(__pyx_t_4);
-    __pyx_t_4 = 0;
-    __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_pi, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_4);
-    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_r = __pyx_t_6;
-    __pyx_t_6 = 0;
-    __Pyx_XGIVEREF(__pyx_t_1);
-    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
-    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
-    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
-    __Pyx_XGIVEREF(__pyx_r);
-    __Pyx_RefNannyFinishContext();
-    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
-    /* return from generator, yielding value */
-    __pyx_generator->resume_label = 1;
-    return __pyx_r;
-    __pyx_L6_resume_from_yield:;
-    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
-    __pyx_cur_scope->__pyx_t_0 = 0;
-    __Pyx_XGOTREF(__pyx_t_1);
-    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
-    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
-    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 217, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_i); __pyx_8genexpr4__pyx_v_i = 0;
+    goto __pyx_L10_exit_scope;
+    __pyx_L6_error:;
+    __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_i); __pyx_8genexpr4__pyx_v_i = 0;
+    goto __pyx_L1_error;
+    __pyx_L10_exit_scope:;
+  } /* exit inner scope */
+  __pyx_v_chars = ((PyObject*)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":247
+ *         return
+ *     chars = [base_implicant[i] for i in idxs]
+ *     _permute_assign(base_implicant, idxs, chars, 0, n, stack, seen)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_f_4cana_12canalization_21cboolean_canalization__permute_assign(__pyx_v_base_implicant, __pyx_v_idxs, __pyx_v_chars, 0, __pyx_v_n, __pyx_v_stack, __pyx_v_seen); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 247, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":242
+ * 
+ * @cython.cfunc
+ * cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t n = len(idxs)
+ *     if n <= 1:
+ */
 
   /* function exit code */
-  PyErr_SetNone(PyExc_StopIteration);
   goto __pyx_L0;
   __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
   __Pyx_XDECREF(__pyx_t_4);
   __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization._enqueue_permutations", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
-  #if !CYTHON_USE_EXC_INFO_STACK
-  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
-  #endif
-  __pyx_generator->resume_label = -1;
-  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_XDECREF(__pyx_v_chars);
+  __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_i);
   __Pyx_RefNannyFinishContext();
-  return __pyx_r;
 }
 
-/* "cana/canalization/cboolean_canalization.pyx":201
- * 
- * 
- * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
- * 
+/* "cana/canalization/cboolean_canalization.pyx":252
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):             # <<<<<<<<<<<<<<
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
  */
 
-static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_16input_wildcard_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *__pyx_cur_scope;
-  Py_ssize_t __pyx_v_k;
-  PyObject *__pyx_v_input_to_wildcards = NULL;
-  PyObject *__pyx_v_binstate = NULL;
-  Py_ssize_t __pyx_8genexpr1__pyx_v_i;
-  PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator1 = 0;
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static PyObject *__pyx_f_4cana_12canalization_21cboolean_canalization_expand_ts_logic_fast(PyObject *__pyx_v_two_symbols, PyObject *__pyx_v_permut_indexes, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  PyObject *__pyx_v_idx_groups = 0;
+  PyObject *__pyx_v_stack = 0;
+  PyObject *__pyx_v_results = 0;
+  PyObject *__pyx_v_seen = 0;
+  PyObject *__pyx_v_implicant = 0;
+  PyObject *__pyx_v_key = 0;
+  PyObject *__pyx_v_idxs = 0;
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  Py_ssize_t __pyx_t_3;
-  Py_ssize_t __pyx_t_4;
-  Py_ssize_t __pyx_t_5;
-  PyObject *__pyx_t_6 = NULL;
-  PyObject *(*__pyx_t_7)(PyObject *);
-  PyObject *__pyx_t_8 = NULL;
-  PyObject *__pyx_t_9 = NULL;
-  PyObject *(*__pyx_t_10)(PyObject *);
-  Py_ssize_t __pyx_t_11;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("input_wildcard_coverage", 0);
-  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage, __pyx_empty_tuple, NULL);
-  if (unlikely(!__pyx_cur_scope)) {
-    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)Py_None);
-    __Pyx_INCREF(Py_None);
-    __PYX_ERR(0, 201, __pyx_L1_error)
-  } else {
-    __Pyx_GOTREF(__pyx_cur_scope);
+  __Pyx_RefNannySetupContext("expand_ts_logic_fast", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":254
+ * cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)             # <<<<<<<<<<<<<<
+ *     if not idx_groups:
+ *         return _init_implicant_stack(two_symbols)
+ */
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization__normalize_index_groups(__pyx_v_permut_indexes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_idx_groups = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":255
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:             # <<<<<<<<<<<<<<
+ *         return _init_implicant_stack(two_symbols)
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_idx_groups != Py_None)&&(PyList_GET_SIZE(__pyx_v_idx_groups) != 0);
+  __pyx_t_3 = (!__pyx_t_2);
+  if (__pyx_t_3) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":256
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:
+ *         return _init_implicant_stack(two_symbols)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef list stack = _init_implicant_stack(two_symbols)
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization__init_implicant_stack(__pyx_v_two_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_r = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
+    goto __pyx_L0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":255
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:             # <<<<<<<<<<<<<<
+ *         return _init_implicant_stack(two_symbols)
+ * 
+ */
   }
 
-  /* "cana/canalization/cboolean_canalization.pyx":212
- *     """
- *     # number of inputs
- *     k = len(next(iter(pi_coverage)))             # <<<<<<<<<<<<<<
+  /* "cana/canalization/cboolean_canalization.pyx":258
+ *         return _init_implicant_stack(two_symbols)
  * 
- *     input_to_wildcards = {i: dict() for i in range(k)}
+ *     cdef list stack = _init_implicant_stack(two_symbols)             # <<<<<<<<<<<<<<
+ *     cdef list results = []
+ *     cdef set seen = set()
  */
-  __pyx_t_1 = PyObject_GetIter(__pyx_v_pi_coverage); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error)
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization__init_implicant_stack(__pyx_v_two_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 258, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyIter_Next(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_3 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 212, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_v_k = __pyx_t_3;
+  __pyx_v_stack = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":214
- *     k = len(next(iter(pi_coverage)))
+  /* "cana/canalization/cboolean_canalization.pyx":259
  * 
- *     input_to_wildcards = {i: dict() for i in range(k)}             # <<<<<<<<<<<<<<
- *     for binstate, piset in pi_coverage.items():
- *         for i in range(k):
+ *     cdef list stack = _init_implicant_stack(two_symbols)
+ *     cdef list results = []             # <<<<<<<<<<<<<<
+ *     cdef set seen = set()
+ *     cdef list implicant
  */
-  { /* enter inner scope */
-    __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __pyx_v_k;
-    __pyx_t_4 = __pyx_t_3;
-    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
-      __pyx_8genexpr1__pyx_v_i = __pyx_t_5;
-      __pyx_t_1 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 214, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 214, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_t_1, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 214, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    }
-  } /* exit inner scope */
-  __pyx_v_input_to_wildcards = ((PyObject*)__pyx_t_2);
-  __pyx_t_2 = 0;
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_results = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":260
+ *     cdef list stack = _init_implicant_stack(two_symbols)
+ *     cdef list results = []
+ *     cdef set seen = set()             # <<<<<<<<<<<<<<
+ *     cdef list implicant
+ *     cdef tuple key
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seen = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":215
+  /* "cana/canalization/cboolean_canalization.pyx":265
+ *     cdef list idxs
  * 
- *     input_to_wildcards = {i: dict() for i in range(k)}
- *     for binstate, piset in pi_coverage.items():             # <<<<<<<<<<<<<<
- *         for i in range(k):
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+ *     while stack:             # <<<<<<<<<<<<<<
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
  */
-  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pi_coverage, __pyx_n_s_items); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 215, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_t_1 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
-    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6);
-    if (likely(__pyx_t_1)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-      __Pyx_INCREF(__pyx_t_1);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_6, function);
+  while (1) {
+    __pyx_t_3 = (__pyx_v_stack != Py_None)&&(PyList_GET_SIZE(__pyx_v_stack) != 0);
+    if (!__pyx_t_3) break;
+
+    /* "cana/canalization/cboolean_canalization.pyx":266
+ * 
+ *     while stack:
+ *         implicant = <list>stack.pop()             # <<<<<<<<<<<<<<
+ *         key = tuple(implicant)
+ *         if key in seen:
+ */
+    if (unlikely(__pyx_v_stack == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+      __PYX_ERR(0, 266, __pyx_L1_error)
     }
-  }
-  __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
-    __pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6); __pyx_t_3 = 0;
-    __pyx_t_7 = NULL;
-  } else {
-    __pyx_t_3 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 215, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 215, __pyx_L1_error)
-  }
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  for (;;) {
-    if (likely(!__pyx_t_7)) {
-      if (likely(PyList_CheckExact(__pyx_t_6))) {
-        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_6)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 215, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      } else {
-        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 215, __pyx_L1_error)
-        #else
-        __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_2);
-        #endif
-      }
-    } else {
-      __pyx_t_2 = __pyx_t_7(__pyx_t_6);
-      if (unlikely(!__pyx_t_2)) {
-        PyObject* exc_type = PyErr_Occurred();
-        if (exc_type) {
-          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 215, __pyx_L1_error)
-        }
-        break;
-      }
-      __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_1 = __Pyx_PyList_Pop(__pyx_v_stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __pyx_t_1;
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_implicant, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":267
+ *     while stack:
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)             # <<<<<<<<<<<<<<
+ *         if key in seen:
+ *             continue
+ */
+    if (unlikely(__pyx_v_implicant == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 267, __pyx_L1_error)
+    }
+    __pyx_t_4 = PyList_AsTuple(__pyx_v_implicant); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_XDECREF_SET(__pyx_v_key, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":268
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
+ *         if key in seen:             # <<<<<<<<<<<<<<
+ *             continue
+ *         seen.add(key)
+ */
+    __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_key, __pyx_v_seen, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 268, __pyx_L1_error)
+    if (__pyx_t_3) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":269
+ *         key = tuple(implicant)
+ *         if key in seen:
+ *             continue             # <<<<<<<<<<<<<<
+ *         seen.add(key)
+ *         results.append(list(implicant))
+ */
+      goto __pyx_L4_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":268
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
+ *         if key in seen:             # <<<<<<<<<<<<<<
+ *             continue
+ *         seen.add(key)
+ */
+    }
+
+    /* "cana/canalization/cboolean_canalization.pyx":270
+ *         if key in seen:
+ *             continue
+ *         seen.add(key)             # <<<<<<<<<<<<<<
+ *         results.append(list(implicant))
+ *         for idxs in idx_groups:
+ */
+    __pyx_t_5 = PySet_Add(__pyx_v_seen, __pyx_v_key); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 270, __pyx_L1_error)
+
+    /* "cana/canalization/cboolean_canalization.pyx":271
+ *             continue
+ *         seen.add(key)
+ *         results.append(list(implicant))             # <<<<<<<<<<<<<<
+ *         for idxs in idx_groups:
+ *             if not idxs:
+ */
+    __pyx_t_4 = PySequence_List(__pyx_v_implicant); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 271, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_results, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 271, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":272
+ *         seen.add(key)
+ *         results.append(list(implicant))
+ *         for idxs in idx_groups:             # <<<<<<<<<<<<<<
+ *             if not idxs:
+ *                 continue
+ */
+    if (unlikely(__pyx_v_idx_groups == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 272, __pyx_L1_error)
     }
-    if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
-      PyObject* sequence = __pyx_t_2;
-      Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-      if (unlikely(size != 2)) {
-        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-        __PYX_ERR(0, 215, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_idx_groups; __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_6 = 0;
+    for (;;) {
+      {
+        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 272, __pyx_L1_error)
+        #endif
+        if (__pyx_t_6 >= __pyx_temp) break;
       }
       #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-      if (likely(PyTuple_CheckExact(sequence))) {
-        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
-        __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); 
-      } else {
-        __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
-        __pyx_t_8 = PyList_GET_ITEM(sequence, 1); 
-      }
-      __Pyx_INCREF(__pyx_t_1);
-      __Pyx_INCREF(__pyx_t_8);
+      __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 272, __pyx_L1_error)
       #else
-      __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error)
+      __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 272, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
       #endif
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    } else {
-      Py_ssize_t index = -1;
-      __pyx_t_9 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 215, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_9);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
-      index = 0; __pyx_t_1 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_1)) goto __pyx_L7_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_1);
-      index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L7_unpacking_failed;
-      __Pyx_GOTREF(__pyx_t_8);
-      if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
-      __pyx_t_10 = NULL;
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      goto __pyx_L8_unpacking_done;
-      __pyx_L7_unpacking_failed:;
-      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
-      __pyx_t_10 = NULL;
-      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-      __PYX_ERR(0, 215, __pyx_L1_error)
-      __pyx_L8_unpacking_done:;
-    }
-    __Pyx_XDECREF_SET(__pyx_v_binstate, __pyx_t_1);
-    __pyx_t_1 = 0;
-    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_piset);
-    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_piset, __pyx_t_8);
-    __Pyx_GIVEREF(__pyx_t_8);
-    __pyx_t_8 = 0;
-
-    /* "cana/canalization/cboolean_canalization.pyx":216
- *     input_to_wildcards = {i: dict() for i in range(k)}
- *     for binstate, piset in pi_coverage.items():
- *         for i in range(k):             # <<<<<<<<<<<<<<
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
- * 
+      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 272, __pyx_L1_error)
+      __Pyx_XDECREF_SET(__pyx_v_idxs, ((PyObject*)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":273
+ *         results.append(list(implicant))
+ *         for idxs in idx_groups:
+ *             if not idxs:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
  */
-    __pyx_t_4 = __pyx_v_k;
-    __pyx_t_5 = __pyx_t_4;
-    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_5; __pyx_t_11+=1) {
-      __pyx_cur_scope->__pyx_v_i = __pyx_t_11;
-
-      /* "cana/canalization/cboolean_canalization.pyx":217
- *     for binstate, piset in pi_coverage.items():
- *         for i in range(k):
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)             # <<<<<<<<<<<<<<
+      __pyx_t_3 = (__pyx_v_idxs != Py_None)&&(PyList_GET_SIZE(__pyx_v_idxs) != 0);
+      __pyx_t_2 = (!__pyx_t_3);
+      if (__pyx_t_2) {
+
+        /* "cana/canalization/cboolean_canalization.pyx":274
+ *         for idxs in idx_groups:
+ *             if not idxs:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
  * 
- *     return input_to_wildcards
  */
-      __pyx_t_2 = __pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_8 = __Pyx_PySequence_Tuple(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 217, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_8);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __pyx_t_2 = PyInt_FromSsize_t(__pyx_cur_scope->__pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_2);
-      __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_input_to_wildcards, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_binstate, __pyx_t_8) < 0)) __PYX_ERR(0, 217, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    }
+        goto __pyx_L7_continue;
+
+        /* "cana/canalization/cboolean_canalization.pyx":273
+ *         results.append(list(implicant))
+ *         for idxs in idx_groups:
+ *             if not idxs:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ */
+      }
 
-    /* "cana/canalization/cboolean_canalization.pyx":215
+      /* "cana/canalization/cboolean_canalization.pyx":275
+ *             if not idxs:
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)             # <<<<<<<<<<<<<<
  * 
- *     input_to_wildcards = {i: dict() for i in range(k)}
- *     for binstate, piset in pi_coverage.items():             # <<<<<<<<<<<<<<
- *         for i in range(k):
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+ *     return results
  */
+      __pyx_f_4cana_12canalization_21cboolean_canalization__enqueue_permutations(__pyx_v_implicant, __pyx_v_idxs, __pyx_v_stack, __pyx_v_seen); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 275, __pyx_L1_error)
+
+      /* "cana/canalization/cboolean_canalization.pyx":272
+ *         seen.add(key)
+ *         results.append(list(implicant))
+ *         for idxs in idx_groups:             # <<<<<<<<<<<<<<
+ *             if not idxs:
+ *                 continue
+ */
+      __pyx_L7_continue:;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_L4_continue:;
   }
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":219
- *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+  /* "cana/canalization/cboolean_canalization.pyx":277
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ * 
+ *     return results             # <<<<<<<<<<<<<<
+ * 
  * 
- *     return input_to_wildcards             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __Pyx_INCREF(__pyx_v_input_to_wildcards);
-  __pyx_r = __pyx_v_input_to_wildcards;
+  __Pyx_INCREF(__pyx_v_results);
+  __pyx_r = __pyx_v_results;
   goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":201
- * 
- * 
- * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
- * 
+  /* "cana/canalization/cboolean_canalization.pyx":252
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):             # <<<<<<<<<<<<<<
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
  */
 
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_9);
-  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.input_wildcard_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_ts_logic_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
   __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_input_to_wildcards);
-  __Pyx_XDECREF(__pyx_v_binstate);
-  __Pyx_XDECREF(__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator1);
-  __Pyx_DECREF(((PyObject *)__pyx_cur_scope));
+  __Pyx_XDECREF(__pyx_v_idx_groups);
+  __Pyx_XDECREF(__pyx_v_stack);
+  __Pyx_XDECREF(__pyx_v_results);
+  __Pyx_XDECREF(__pyx_v_seen);
+  __Pyx_XDECREF(__pyx_v_implicant);
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_idxs);
   __Pyx_XGIVEREF(__pyx_r);
   __Pyx_RefNannyFinishContext();
   return __pyx_r;
 }
 
-static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers[8];
-static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers = 0;
-
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
-  PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers)))) {
-    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers];
-    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers));
-    (void) PyObject_INIT(o, t);
-    PyObject_GC_Track(o);
-  } else {
-    o = (*t->tp_alloc)(t, 0);
-    if (unlikely(!o)) return 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_12expand_ts_logic_fast, "Generate all permutations for two-symbol schemata groups.");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast = {"expand_ts_logic_fast", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_12expand_ts_logic_fast};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_two_symbols = 0;
+  PyObject *__pyx_v_permut_indexes = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("expand_ts_logic_fast (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_two_symbols,&__pyx_n_s_permut_indexes,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_two_symbols)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_permut_indexes)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 252, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("expand_ts_logic_fast", 1, 2, 2, 1); __PYX_ERR(0, 252, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "expand_ts_logic_fast") < 0)) __PYX_ERR(0, 252, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+    }
+    __pyx_v_two_symbols = values[0];
+    __pyx_v_permut_indexes = values[1];
   }
-  return o;
-}
-
-static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(PyObject *o) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)o;
-  PyObject_GC_UnTrack(o);
-  Py_CLEAR(p->__pyx_v_implicant);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers)))) {
-    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)o);
-  } else {
-    (*Py_TYPE(o)->tp_free)(o);
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("expand_ts_logic_fast", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 252, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
   }
-}
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_ts_logic_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_ts_logic_fast(__pyx_self, __pyx_v_two_symbols, __pyx_v_permut_indexes);
 
-static int __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)o;
-  if (p->__pyx_v_implicant) {
-    e = (*v)(p->__pyx_v_implicant, a); if (e) return e;
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
   }
-  return 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static int __pyx_tp_clear_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers *)o;
-  tmp = ((PyObject*)p->__pyx_v_implicant);
-  p->__pyx_v_implicant = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  return 0;
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_12expand_ts_logic_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_two_symbols, PyObject *__pyx_v_permut_indexes) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("expand_ts_logic_fast", 1);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization_expand_ts_logic_fast(__pyx_v_two_symbols, __pyx_v_permut_indexes, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_ts_logic_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "cana.canalization.cboolean_canalization.__pyx_scope_struct____pi_covers", /*tp_name*/
-  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers, /*tp_traverse*/
-  __pyx_tp_clear_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  0, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
-  #endif
-};
+/* "cana/canalization/cboolean_canalization.pyx":282
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
 
-static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[8];
-static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = 0;
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_15ts_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static int __pyx_f_4cana_12canalization_21cboolean_canalization_ts_covers_fast(PyObject *__pyx_v_two_symbol, PyObject *__pyx_v_permut_indexes, PyObject *__pyx_v_binstate, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  PyObject *__pyx_v_idx_groups = 0;
+  PyObject *__pyx_v_stack = 0;
+  PyObject *__pyx_v_seen = 0;
+  PyObject *__pyx_v_implicant = 0;
+  PyObject *__pyx_v_key = 0;
+  PyObject *__pyx_v_idxs = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  Py_ssize_t __pyx_t_6;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ts_covers_fast", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":284
+ * cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)             # <<<<<<<<<<<<<<
+ *     if not idx_groups:
+ *         return pi_covers_fast(two_symbol, binstate)
+ */
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization__normalize_index_groups(__pyx_v_permut_indexes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_idx_groups = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
-  PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr)))) {
-    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr];
-    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr));
-    (void) PyObject_INIT(o, t);
-    PyObject_GC_Track(o);
-  } else {
-    o = (*t->tp_alloc)(t, 0);
-    if (unlikely(!o)) return 0;
-  }
-  return o;
-}
+  /* "cana/canalization/cboolean_canalization.pyx":285
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:             # <<<<<<<<<<<<<<
+ *         return pi_covers_fast(two_symbol, binstate)
+ * 
+ */
+  __pyx_t_2 = (__pyx_v_idx_groups != Py_None)&&(PyList_GET_SIZE(__pyx_v_idx_groups) != 0);
+  __pyx_t_3 = (!__pyx_t_2);
+  if (__pyx_t_3) {
+
+    /* "cana/canalization/cboolean_canalization.pyx":286
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:
+ *         return pi_covers_fast(two_symbol, binstate)             # <<<<<<<<<<<<<<
+ * 
+ *     cdef list stack = _init_implicant_stack(two_symbol)
+ */
+    __pyx_t_3 = __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(__pyx_v_two_symbol, __pyx_v_binstate, 0); if (unlikely(__pyx_t_3 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 286, __pyx_L1_error)
+    __pyx_r = __pyx_t_3;
+    goto __pyx_L0;
 
-static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyObject *o) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o;
-  PyObject_GC_UnTrack(o);
-  Py_CLEAR(p->__pyx_outer_scope);
-  Py_CLEAR(p->__pyx_v_i);
-  Py_CLEAR(p->__pyx_v_m);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr)))) {
-    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o);
-  } else {
-    (*Py_TYPE(o)->tp_free)(o);
+    /* "cana/canalization/cboolean_canalization.pyx":285
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ *     if not idx_groups:             # <<<<<<<<<<<<<<
+ *         return pi_covers_fast(two_symbol, binstate)
+ * 
+ */
   }
-}
 
-static int __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o;
-  if (p->__pyx_outer_scope) {
-    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
-  }
-  if (p->__pyx_v_i) {
-    e = (*v)(p->__pyx_v_i, a); if (e) return e;
-  }
-  if (p->__pyx_v_m) {
-    e = (*v)(p->__pyx_v_m, a); if (e) return e;
-  }
-  return 0;
-}
+  /* "cana/canalization/cboolean_canalization.pyx":288
+ *         return pi_covers_fast(two_symbol, binstate)
+ * 
+ *     cdef list stack = _init_implicant_stack(two_symbol)             # <<<<<<<<<<<<<<
+ *     cdef set seen = set()
+ *     cdef list implicant
+ */
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization__init_implicant_stack(__pyx_v_two_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_stack = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "cana.canalization.cboolean_canalization.__pyx_scope_struct_1_genexpr", /*tp_name*/
-  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_traverse*/
-  0, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  0, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
-  #endif
-};
+  /* "cana/canalization/cboolean_canalization.pyx":289
+ * 
+ *     cdef list stack = _init_implicant_stack(two_symbol)
+ *     cdef set seen = set()             # <<<<<<<<<<<<<<
+ *     cdef list implicant
+ *     cdef tuple key
+ */
+  __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seen = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage[8];
-static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage = 0;
+  /* "cana/canalization/cboolean_canalization.pyx":294
+ *     cdef list idxs
+ * 
+ *     while stack:             # <<<<<<<<<<<<<<
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
+ */
+  while (1) {
+    __pyx_t_3 = (__pyx_v_stack != Py_None)&&(PyList_GET_SIZE(__pyx_v_stack) != 0);
+    if (!__pyx_t_3) break;
 
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
-  PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage)))) {
-    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage];
-    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage));
-    (void) PyObject_INIT(o, t);
-    PyObject_GC_Track(o);
-  } else {
-    o = (*t->tp_alloc)(t, 0);
-    if (unlikely(!o)) return 0;
-  }
-  return o;
-}
+    /* "cana/canalization/cboolean_canalization.pyx":295
+ * 
+ *     while stack:
+ *         implicant = <list>stack.pop()             # <<<<<<<<<<<<<<
+ *         key = tuple(implicant)
+ *         if key in seen:
+ */
+    if (unlikely(__pyx_v_stack == Py_None)) {
+      PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "pop");
+      __PYX_ERR(0, 295, __pyx_L1_error)
+    }
+    __pyx_t_1 = __Pyx_PyList_Pop(__pyx_v_stack); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_4 = __pyx_t_1;
+    __Pyx_INCREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_implicant, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
 
-static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(PyObject *o) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)o;
-  PyObject_GC_UnTrack(o);
-  Py_CLEAR(p->__pyx_v_piset);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage)))) {
-    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)o);
-  } else {
-    (*Py_TYPE(o)->tp_free)(o);
-  }
-}
+    /* "cana/canalization/cboolean_canalization.pyx":296
+ *     while stack:
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)             # <<<<<<<<<<<<<<
+ *         if key in seen:
+ *             continue
+ */
+    if (unlikely(__pyx_v_implicant == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 296, __pyx_L1_error)
+    }
+    __pyx_t_4 = PyList_AsTuple(__pyx_v_implicant); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 296, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_XDECREF_SET(__pyx_v_key, ((PyObject*)__pyx_t_4));
+    __pyx_t_4 = 0;
 
-static int __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)o;
-  if (p->__pyx_v_piset) {
-    e = (*v)(p->__pyx_v_piset, a); if (e) return e;
-  }
-  return 0;
-}
+    /* "cana/canalization/cboolean_canalization.pyx":297
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
+ *         if key in seen:             # <<<<<<<<<<<<<<
+ *             continue
+ *         seen.add(key)
+ */
+    __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_key, __pyx_v_seen, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 297, __pyx_L1_error)
+    if (__pyx_t_3) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":298
+ *         key = tuple(implicant)
+ *         if key in seen:
+ *             continue             # <<<<<<<<<<<<<<
+ *         seen.add(key)
+ *         if pi_covers_fast(implicant, binstate):
+ */
+      goto __pyx_L4_continue;
+
+      /* "cana/canalization/cboolean_canalization.pyx":297
+ *         implicant = <list>stack.pop()
+ *         key = tuple(implicant)
+ *         if key in seen:             # <<<<<<<<<<<<<<
+ *             continue
+ *         seen.add(key)
+ */
+    }
 
-static int __pyx_tp_clear_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage(PyObject *o) {
-  PyObject* tmp;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage *)o;
-  tmp = ((PyObject*)p->__pyx_v_piset);
-  p->__pyx_v_piset = Py_None; Py_INCREF(Py_None);
-  Py_XDECREF(tmp);
-  return 0;
-}
+    /* "cana/canalization/cboolean_canalization.pyx":299
+ *         if key in seen:
+ *             continue
+ *         seen.add(key)             # <<<<<<<<<<<<<<
+ *         if pi_covers_fast(implicant, binstate):
+ *             return True
+ */
+    __pyx_t_5 = PySet_Add(__pyx_v_seen, __pyx_v_key); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 299, __pyx_L1_error)
+
+    /* "cana/canalization/cboolean_canalization.pyx":300
+ *             continue
+ *         seen.add(key)
+ *         if pi_covers_fast(implicant, binstate):             # <<<<<<<<<<<<<<
+ *             return True
+ *         for idxs in idx_groups:
+ */
+    __pyx_t_3 = __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(__pyx_v_implicant, __pyx_v_binstate, 0); if (unlikely(__pyx_t_3 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L1_error)
+    if (__pyx_t_3) {
+
+      /* "cana/canalization/cboolean_canalization.pyx":301
+ *         seen.add(key)
+ *         if pi_covers_fast(implicant, binstate):
+ *             return True             # <<<<<<<<<<<<<<
+ *         for idxs in idx_groups:
+ *             if not idxs:
+ */
+      __pyx_r = 1;
+      goto __pyx_L0;
 
-static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "cana.canalization.cboolean_canalization.__pyx_scope_struct_2_input_wildcard_coverage", /*tp_name*/
-  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage, /*tp_traverse*/
-  __pyx_tp_clear_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  0, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
-  #endif
-};
+      /* "cana/canalization/cboolean_canalization.pyx":300
+ *             continue
+ *         seen.add(key)
+ *         if pi_covers_fast(implicant, binstate):             # <<<<<<<<<<<<<<
+ *             return True
+ *         for idxs in idx_groups:
+ */
+    }
 
-static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr[8];
-static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr = 0;
+    /* "cana/canalization/cboolean_canalization.pyx":302
+ *         if pi_covers_fast(implicant, binstate):
+ *             return True
+ *         for idxs in idx_groups:             # <<<<<<<<<<<<<<
+ *             if not idxs:
+ *                 continue
+ */
+    if (unlikely(__pyx_v_idx_groups == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+      __PYX_ERR(0, 302, __pyx_L1_error)
+    }
+    __pyx_t_4 = __pyx_v_idx_groups; __Pyx_INCREF(__pyx_t_4);
+    __pyx_t_6 = 0;
+    for (;;) {
+      {
+        Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 302, __pyx_L1_error)
+        #endif
+        if (__pyx_t_6 >= __pyx_temp) break;
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 302, __pyx_L1_error)
+      #else
+      __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      #endif
+      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 302, __pyx_L1_error)
+      __Pyx_XDECREF_SET(__pyx_v_idxs, ((PyObject*)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":303
+ *             return True
+ *         for idxs in idx_groups:
+ *             if not idxs:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ */
+      __pyx_t_3 = (__pyx_v_idxs != Py_None)&&(PyList_GET_SIZE(__pyx_v_idxs) != 0);
+      __pyx_t_2 = (!__pyx_t_3);
+      if (__pyx_t_2) {
+
+        /* "cana/canalization/cboolean_canalization.pyx":304
+ *         for idxs in idx_groups:
+ *             if not idxs:
+ *                 continue             # <<<<<<<<<<<<<<
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ * 
+ */
+        goto __pyx_L8_continue;
+
+        /* "cana/canalization/cboolean_canalization.pyx":303
+ *             return True
+ *         for idxs in idx_groups:
+ *             if not idxs:             # <<<<<<<<<<<<<<
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ */
+      }
 
-static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
-  PyObject *o;
-  if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr)))) {
-    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr];
-    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr));
-    (void) PyObject_INIT(o, t);
-    PyObject_GC_Track(o);
-  } else {
-    o = (*t->tp_alloc)(t, 0);
-    if (unlikely(!o)) return 0;
+      /* "cana/canalization/cboolean_canalization.pyx":305
+ *             if not idxs:
+ *                 continue
+ *             _enqueue_permutations(implicant, idxs, stack, seen)             # <<<<<<<<<<<<<<
+ * 
+ *     return False
+ */
+      __pyx_f_4cana_12canalization_21cboolean_canalization__enqueue_permutations(__pyx_v_implicant, __pyx_v_idxs, __pyx_v_stack, __pyx_v_seen); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 305, __pyx_L1_error)
+
+      /* "cana/canalization/cboolean_canalization.pyx":302
+ *         if pi_covers_fast(implicant, binstate):
+ *             return True
+ *         for idxs in idx_groups:             # <<<<<<<<<<<<<<
+ *             if not idxs:
+ *                 continue
+ */
+      __pyx_L8_continue:;
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_L4_continue:;
   }
-  return o;
-}
 
-static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr(PyObject *o) {
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)o;
-  PyObject_GC_UnTrack(o);
-  Py_CLEAR(p->__pyx_outer_scope);
-  Py_CLEAR(p->__pyx_v_pi);
-  Py_CLEAR(p->__pyx_t_0);
-  if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr)))) {
-    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)o);
-  } else {
-    (*Py_TYPE(o)->tp_free)(o);
-  }
+  /* "cana/canalization/cboolean_canalization.pyx":307
+ *             _enqueue_permutations(implicant, idxs, stack, seen)
+ * 
+ *     return False             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = 0;
+  goto __pyx_L0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":282
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.ts_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_idx_groups);
+  __Pyx_XDECREF(__pyx_v_stack);
+  __Pyx_XDECREF(__pyx_v_seen);
+  __Pyx_XDECREF(__pyx_v_implicant);
+  __Pyx_XDECREF(__pyx_v_key);
+  __Pyx_XDECREF(__pyx_v_idxs);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static int __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr(PyObject *o, visitproc v, void *a) {
-  int e;
-  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr *)o;
-  if (p->__pyx_outer_scope) {
-    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_15ts_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_14ts_covers_fast, "Fast coverage test for two-symbol schemata with permutations.");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_15ts_covers_fast = {"ts_covers_fast", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_15ts_covers_fast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_14ts_covers_fast};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_15ts_covers_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_two_symbol = 0;
+  PyObject *__pyx_v_permut_indexes = 0;
+  PyObject *__pyx_v_binstate = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[3] = {0,0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("ts_covers_fast (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_two_symbol,&__pyx_n_s_permut_indexes,&__pyx_n_s_binstate,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_two_symbol)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 282, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_permut_indexes)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 282, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("ts_covers_fast", 1, 3, 3, 1); __PYX_ERR(0, 282, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[2]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 282, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("ts_covers_fast", 1, 3, 3, 2); __PYX_ERR(0, 282, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ts_covers_fast") < 0)) __PYX_ERR(0, 282, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 3)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+      values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2);
+    }
+    __pyx_v_two_symbol = values[0];
+    __pyx_v_permut_indexes = values[1];
+    __pyx_v_binstate = values[2];
   }
-  if (p->__pyx_v_pi) {
-    e = (*v)(p->__pyx_v_pi, a); if (e) return e;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("ts_covers_fast", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 282, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
   }
-  if (p->__pyx_t_0) {
-    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.ts_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_14ts_covers_fast(__pyx_self, __pyx_v_two_symbol, __pyx_v_permut_indexes, __pyx_v_binstate);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
   }
-  return 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr = {
-  PyVarObject_HEAD_INIT(0, 0)
-  "cana.canalization.cboolean_canalization.__pyx_scope_struct_3_genexpr", /*tp_name*/
-  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr), /*tp_basicsize*/
-  0, /*tp_itemsize*/
-  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr, /*tp_dealloc*/
-  #if PY_VERSION_HEX < 0x030800b4
-  0, /*tp_print*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4
-  0, /*tp_vectorcall_offset*/
-  #endif
-  0, /*tp_getattr*/
-  0, /*tp_setattr*/
-  #if PY_MAJOR_VERSION < 3
-  0, /*tp_compare*/
-  #endif
-  #if PY_MAJOR_VERSION >= 3
-  0, /*tp_as_async*/
-  #endif
-  0, /*tp_repr*/
-  0, /*tp_as_number*/
-  0, /*tp_as_sequence*/
-  0, /*tp_as_mapping*/
-  0, /*tp_hash*/
-  0, /*tp_call*/
-  0, /*tp_str*/
-  0, /*tp_getattro*/
-  0, /*tp_setattro*/
-  0, /*tp_as_buffer*/
-  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-  0, /*tp_doc*/
-  __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr, /*tp_traverse*/
-  0, /*tp_clear*/
-  0, /*tp_richcompare*/
-  0, /*tp_weaklistoffset*/
-  0, /*tp_iter*/
-  0, /*tp_iternext*/
-  0, /*tp_methods*/
-  0, /*tp_members*/
-  0, /*tp_getset*/
-  0, /*tp_base*/
-  0, /*tp_dict*/
-  0, /*tp_descr_get*/
-  0, /*tp_descr_set*/
-  0, /*tp_dictoffset*/
-  0, /*tp_init*/
-  0, /*tp_alloc*/
-  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr, /*tp_new*/
-  0, /*tp_free*/
-  0, /*tp_is_gc*/
-  0, /*tp_bases*/
-  0, /*tp_mro*/
-  0, /*tp_cache*/
-  0, /*tp_subclasses*/
-  0, /*tp_weaklist*/
-  0, /*tp_del*/
-  0, /*tp_version_tag*/
-  #if PY_VERSION_HEX >= 0x030400a1
-  0, /*tp_finalize*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
-  0, /*tp_vectorcall*/
-  #endif
-  #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
-  0, /*tp_print*/
-  #endif
-  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
-  0, /*tp_pypy_flags*/
-  #endif
-};
-
-static PyMethodDef __pyx_methods[] = {
-  {0, 0, 0, 0}
-};
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_14ts_covers_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_two_symbol, PyObject *__pyx_v_permut_indexes, PyObject *__pyx_v_binstate) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("ts_covers_fast", 1);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization_ts_covers_fast(__pyx_v_two_symbol, __pyx_v_permut_indexes, __pyx_v_binstate, 0); if (unlikely(__pyx_t_1 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 282, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-static int __pyx_import_star_set(PyObject *o, PyObject* py_name, char *name) {
-  static const char* internal_type_names[] = {
-    "__pyx_ctuple_Py_ssize_t",
-    "__pyx_ctuple_Py_ssize_t_struct",
-    "__pyx_scope_struct_1_genexpr",
-    "__pyx_scope_struct_2_input_wildcard_coverage",
-    "__pyx_scope_struct_3_genexpr",
-    "__pyx_scope_struct____pi_covers",
-    0
-  };
-  const char** type_name = internal_type_names;
-  while (*type_name) {
-    if (__Pyx_StrEq(name, *type_name)) {
-      PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);
-      goto bad;
-    }
-    type_name++;
-  }
-  if (0);
-  else {
-    if (PyObject_SetAttr(__pyx_m, py_name, o) < 0) goto bad;
-  }
-  return 0;
-  bad:
-  return -1;
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.ts_covers_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
 }
 
-static int
-__Pyx_import_all_from(PyObject *locals, PyObject *v)
-{
-    PyObject *all = PyObject_GetAttrString(v, "__all__");
-    PyObject *dict, *name, *value;
-    int skip_leading_underscores = 0;
-    int pos, err;
-    if (all == NULL) {
-        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-            return -1;
-        PyErr_Clear();
-        dict = PyObject_GetAttrString(v, "__dict__");
-        if (dict == NULL) {
-            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-                return -1;
-            PyErr_SetString(PyExc_ImportError,
-            "from-import-* object has no __dict__ and no __all__");
-            return -1;
-        }
-#if PY_MAJOR_VERSION < 3
-        all = PyObject_CallMethod(dict, (char *)"keys", NULL);
+/* "cana/canalization/cboolean_canalization.pyx":310
+ * 
+ * 
+ * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
+ *     """Determine if a binarystate is covered by a specific implicant."""
+ *     return pi_covers_fast(implicant, binstate)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_17__pi_covers(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 #else
-        all = PyMapping_Keys(dict);
-#endif
-        Py_DECREF(dict);
-        if (all == NULL)
-            return -1;
-        skip_leading_underscores = 1;
-    }
-    for (pos = 0, err = 0; ; pos++) {
-        name = PySequence_GetItem(all, pos);
-        if (name == NULL) {
-            if (!PyErr_ExceptionMatches(PyExc_IndexError))
-                err = -1;
-            else
-                PyErr_Clear();
-            break;
-        }
-        if (skip_leading_underscores &&
-#if PY_MAJOR_VERSION < 3
-            likely(PyString_Check(name)) &&
-            PyString_AS_STRING(name)[0] == '_')
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_16__pi_covers, "Determine if a binarystate is covered by a specific implicant.");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_17__pi_covers = {"__pi_covers", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_17__pi_covers, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_16__pi_covers};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_17__pi_covers(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 #else
-            likely(PyUnicode_Check(name)) &&
-            likely(__Pyx_PyUnicode_GET_LENGTH(name)) &&
-            __Pyx_PyUnicode_READ_CHAR(name, 0) == '_')
+PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
-        {
-            Py_DECREF(name);
-            continue;
+) {
+  PyObject *__pyx_v_implicant = 0;
+  PyObject *__pyx_v_binstate = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__pi_covers (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_implicant,&__pyx_n_s_binstate,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_implicant)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
         }
-        value = PyObject_GetAttr(v, name);
-        if (value == NULL)
-            err = -1;
-        else if (PyDict_CheckExact(locals))
-            err = PyDict_SetItem(locals, name, value);
-        else
-            err = PyObject_SetItem(locals, name, value);
-        Py_DECREF(name);
-        Py_XDECREF(value);
-        if (err != 0)
-            break;
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binstate)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L3_error)
+        else {
+          __Pyx_RaiseArgtupleInvalid("__pi_covers", 1, 2, 2, 1); __PYX_ERR(0, 310, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pi_covers") < 0)) __PYX_ERR(0, 310, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+      values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
-    Py_DECREF(all);
-    return err;
-}
-static int __pyx_import_star(PyObject* m) {
-    int i;
-    int ret = -1;
-    char* s;
-    PyObject *locals = 0;
-    PyObject *list = 0;
-#if PY_MAJOR_VERSION >= 3
-    PyObject *utf8_name = 0;
-#endif
-    PyObject *name;
-    PyObject *item;
-    locals = PyDict_New();              if (!locals) goto bad;
-    if (__Pyx_import_all_from(locals, m) < 0) goto bad;
-    list = PyDict_Items(locals);        if (!list) goto bad;
-    for(i=0; i<PyList_GET_SIZE(list); i++) {
-        name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0);
-        item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1);
-#if PY_MAJOR_VERSION >= 3
-        utf8_name = PyUnicode_AsUTF8String(name);
-        if (!utf8_name) goto bad;
-        s = PyBytes_AS_STRING(utf8_name);
-        if (__pyx_import_star_set(item, name, s) < 0) goto bad;
-        Py_DECREF(utf8_name); utf8_name = 0;
-#else
-        s = PyString_AsString(name);
-        if (!s) goto bad;
-        if (__pyx_import_star_set(item, name, s) < 0) goto bad;
-#endif
+    __pyx_v_implicant = values[0];
+    __pyx_v_binstate = values[1];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__pi_covers", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 310, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
     }
-    ret = 0;
-bad:
-    Py_XDECREF(locals);
-    Py_XDECREF(list);
-#if PY_MAJOR_VERSION >= 3
-    Py_XDECREF(utf8_name);
-#endif
-    return ret;
-}
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.__pi_covers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_16__pi_covers(__pyx_self, __pyx_v_implicant, __pyx_v_binstate);
 
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
 
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_16__pi_covers(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_implicant, PyObject *__pyx_v_binstate) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__pi_covers", 1);
 
-#if PY_MAJOR_VERSION >= 3
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
-static int __pyx_pymod_exec_cboolean_canalization(PyObject* module); /*proto*/
-static PyModuleDef_Slot __pyx_moduledef_slots[] = {
-  {Py_mod_create, (void*)__pyx_pymod_create},
-  {Py_mod_exec, (void*)__pyx_pymod_exec_cboolean_canalization},
-  {0, NULL}
-};
-#endif
-
-static struct PyModuleDef __pyx_moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "cboolean_canalization",
-    __pyx_k_Cythonized_Boolean_Canalization, /* m_doc */
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    0, /* m_size */
-  #else
-    -1, /* m_size */
-  #endif
-    __pyx_methods /* m_methods */,
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-    __pyx_moduledef_slots, /* m_slots */
-  #else
-    NULL, /* m_reload */
-  #endif
-    NULL, /* m_traverse */
-    NULL, /* m_clear */
-    NULL /* m_free */
-};
-#endif
-#ifndef CYTHON_SMALL_CODE
-#if defined(__clang__)
-    #define CYTHON_SMALL_CODE
-#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-    #define CYTHON_SMALL_CODE __attribute__((cold))
-#else
-    #define CYTHON_SMALL_CODE
-#endif
-#endif
-
-static __Pyx_StringTabEntry __pyx_string_tab[] = {
-  {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0},
-  {&__pyx_kp_s_0, __pyx_k_0, sizeof(__pyx_k_0), 0, 0, 1, 0},
-  {&__pyx_kp_s_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 0, 1, 0},
-  {&__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL, __pyx_k_SYMMETRIC_WILDCARD_SYMBOL, sizeof(__pyx_k_SYMMETRIC_WILDCARD_SYMBOL), 0, 0, 1, 1},
-  {&__pyx_n_s_WILDCARD_SYMBOL, __pyx_k_WILDCARD_SYMBOL, sizeof(__pyx_k_WILDCARD_SYMBOL), 0, 0, 1, 1},
-  {&__pyx_n_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 1},
-  {&__pyx_kp_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 0},
-  {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
-  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
-  {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
-  {&__pyx_n_s_b0, __pyx_k_b0, sizeof(__pyx_k_b0), 0, 0, 1, 1},
-  {&__pyx_n_s_b1, __pyx_k_b1, sizeof(__pyx_k_b1), 0, 0, 1, 1},
-  {&__pyx_n_s_binary_density, __pyx_k_binary_density, sizeof(__pyx_k_binary_density), 0, 0, 1, 1},
-  {&__pyx_n_s_binary_states, __pyx_k_binary_states, sizeof(__pyx_k_binary_states), 0, 0, 1, 1},
-  {&__pyx_n_s_binstate, __pyx_k_binstate, sizeof(__pyx_k_binstate), 0, 0, 1, 1},
-  {&__pyx_n_s_binstate0, __pyx_k_binstate0, sizeof(__pyx_k_binstate0), 0, 0, 1, 1},
-  {&__pyx_n_s_binstate1, __pyx_k_binstate1, sizeof(__pyx_k_binstate1), 0, 0, 1, 1},
-  {&__pyx_n_s_binstate2, __pyx_k_binstate2, sizeof(__pyx_k_binstate2), 0, 0, 1, 1},
-  {&__pyx_n_s_cana_canalization_cboolean_canal, __pyx_k_cana_canalization_cboolean_canal, sizeof(__pyx_k_cana_canalization_cboolean_canal), 0, 0, 1, 1},
-  {&__pyx_n_s_cana_cutils, __pyx_k_cana_cutils, sizeof(__pyx_k_cana_cutils), 0, 0, 1, 1},
-  {&__pyx_kp_s_cboolean_canalization_pyx, __pyx_k_cboolean_canalization_pyx, sizeof(__pyx_k_cboolean_canalization_pyx), 0, 0, 1, 0},
-  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
-  {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
-  {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1},
-  {&__pyx_n_s_density, __pyx_k_density, sizeof(__pyx_k_density), 0, 0, 1, 1},
-  {&__pyx_n_s_density_groups, __pyx_k_density_groups, sizeof(__pyx_k_density_groups), 0, 0, 1, 1},
-  {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1},
-  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
-  {&__pyx_n_s_expand_wildcard_schemata, __pyx_k_expand_wildcard_schemata, sizeof(__pyx_k_expand_wildcard_schemata), 0, 0, 1, 1},
-  {&__pyx_n_s_find_implicants_qm, __pyx_k_find_implicants_qm, sizeof(__pyx_k_find_implicants_qm), 0, 0, 1, 1},
-  {&__pyx_n_s_find_wildcards, __pyx_k_find_wildcards, sizeof(__pyx_k_find_wildcards), 0, 0, 1, 1},
-  {&__pyx_n_s_flip_binstate_bit, __pyx_k_flip_binstate_bit, sizeof(__pyx_k_flip_binstate_bit), 0, 0, 1, 1},
-  {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1},
-  {&__pyx_n_s_groups, __pyx_k_groups, sizeof(__pyx_k_groups), 0, 0, 1, 1},
-  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
-  {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1},
-  {&__pyx_n_s_implicant, __pyx_k_implicant, sizeof(__pyx_k_implicant), 0, 0, 1, 1},
-  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
-  {&__pyx_n_s_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 0, 1, 1},
-  {&__pyx_n_s_input_binstates, __pyx_k_input_binstates, sizeof(__pyx_k_input_binstates), 0, 0, 1, 1},
-  {&__pyx_n_s_input_to_wildcards, __pyx_k_input_to_wildcards, sizeof(__pyx_k_input_to_wildcards), 0, 0, 1, 1},
-  {&__pyx_n_s_input_wildcard_coverage, __pyx_k_input_wildcard_coverage, sizeof(__pyx_k_input_wildcard_coverage), 0, 0, 1, 1},
-  {&__pyx_n_s_input_wildcard_coverage_locals_g, __pyx_k_input_wildcard_coverage_locals_g, sizeof(__pyx_k_input_wildcard_coverage_locals_g), 0, 0, 1, 1},
-  {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1},
-  {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1},
-  {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
-  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
-  {&__pyx_n_s_make_density_groups, __pyx_k_make_density_groups, sizeof(__pyx_k_make_density_groups), 0, 0, 1, 1},
-  {&__pyx_n_s_matched_implicants, __pyx_k_matched_implicants, sizeof(__pyx_k_matched_implicants), 0, 0, 1, 1},
-  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
-  {&__pyx_n_s_newstate, __pyx_k_newstate, sizeof(__pyx_k_newstate), 0, 0, 1, 1},
-  {&__pyx_n_s_nwildcards, __pyx_k_nwildcards, sizeof(__pyx_k_nwildcards), 0, 0, 1, 1},
-  {&__pyx_n_s_pi, __pyx_k_pi, sizeof(__pyx_k_pi), 0, 0, 1, 1},
-  {&__pyx_n_s_pi_coverage, __pyx_k_pi_coverage, sizeof(__pyx_k_pi_coverage), 0, 0, 1, 1},
-  {&__pyx_n_s_pi_covers, __pyx_k_pi_covers, sizeof(__pyx_k_pi_covers), 0, 0, 1, 1},
-  {&__pyx_n_s_pi_covers_locals_genexpr, __pyx_k_pi_covers_locals_genexpr, sizeof(__pyx_k_pi_covers_locals_genexpr), 0, 0, 1, 1},
-  {&__pyx_n_s_piset, __pyx_k_piset, sizeof(__pyx_k_piset), 0, 0, 1, 1},
-  {&__pyx_n_s_prime_implicants, __pyx_k_prime_implicants, sizeof(__pyx_k_prime_implicants), 0, 0, 1, 1},
-  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
-  {&__pyx_n_s_replace_wildcard, __pyx_k_replace_wildcard, sizeof(__pyx_k_replace_wildcard), 0, 0, 1, 1},
-  {&__pyx_n_s_return_pi_coverage, __pyx_k_return_pi_coverage, sizeof(__pyx_k_return_pi_coverage), 0, 0, 1, 1},
-  {&__pyx_n_s_schemata, __pyx_k_schemata, sizeof(__pyx_k_schemata), 0, 0, 1, 1},
-  {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1},
-  {&__pyx_n_s_statenum_to_binstate, __pyx_k_statenum_to_binstate, sizeof(__pyx_k_statenum_to_binstate), 0, 0, 1, 1},
-  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
-  {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1},
-  {&__pyx_n_s_used, __pyx_k_used, sizeof(__pyx_k_used), 0, 0, 1, 1},
-  {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1},
-  {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1},
-  {&__pyx_n_s_wildstatenum, __pyx_k_wildstatenum, sizeof(__pyx_k_wildstatenum), 0, 0, 1, 1},
-  {&__pyx_n_s_wildstates, __pyx_k_wildstates, sizeof(__pyx_k_wildstates), 0, 0, 1, 1},
-  {&__pyx_n_s_wnum, __pyx_k_wnum, sizeof(__pyx_k_wnum), 0, 0, 1, 1},
-  {&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1},
-  {0, 0, 0, 0, 0, 0, 0}
-};
-static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 49, __pyx_L1_error)
-  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 110, __pyx_L1_error)
-  __pyx_builtin_input = __Pyx_GetBuiltinName(__pyx_n_s_input); if (!__pyx_builtin_input) __PYX_ERR(0, 146, __pyx_L1_error)
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 167, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
-
-  /* "cana/canalization/cboolean_canalization.pyx":24
- * # Quine-McCluskey Functions
- * #
- * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
- *     """
- *     """
- */
-  __pyx_tuple__4 = PyTuple_Pack(4, __pyx_n_s_input_binstates, __pyx_n_s_density_groups, __pyx_n_s_binstate, __pyx_n_s_density); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__4);
-  __Pyx_GIVEREF(__pyx_tuple__4);
-  __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_make_density_groups, 24, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 24, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":38
- * 
- * 
- * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
- *     """
- *     Compare two binary states and replace any differing bits by a wildcard.
- */
-  __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_binstate1, __pyx_n_s_binstate2, __pyx_n_s_b0, __pyx_n_s_b1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
-  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_find_wildcards, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 38, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":52
- * 
- * 
- * def binary_density(binstate):             # <<<<<<<<<<<<<<
- *     """
- *     Find the density (number of 1s) for a term with possible wildcards.
- */
-  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
-  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_binary_density, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 52, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":59
- * 
- * 
- * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
- *     """
- *     Return the binary state with a wildcard at the idx position.
- */
-  __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_binstate, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 59, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__10);
-  __Pyx_GIVEREF(__pyx_tuple__10);
-  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_replace_wildcard, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 59, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":66
+  /* "cana/canalization/cboolean_canalization.pyx":312
+ * def __pi_covers(implicant, binstate):
+ *     """Determine if a binarystate is covered by a specific implicant."""
+ *     return pi_covers_fast(implicant, binstate)             # <<<<<<<<<<<<<<
  * 
  * 
- * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
- *     """ Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.
- * 
  */
-  __pyx_tuple__12 = PyTuple_Pack(13, __pyx_n_s_input_binstates, __pyx_n_s_verbose, __pyx_n_s_matched_implicants, __pyx_n_s_done, __pyx_n_s_density_groups, __pyx_n_s_used, __pyx_n_s_density, __pyx_n_s_binstate0, __pyx_n_s_idx, __pyx_n_s_b0, __pyx_n_s_binstate1, __pyx_n_s_groups, __pyx_n_s_prime_implicants); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__12);
-  __Pyx_GIVEREF(__pyx_tuple__12);
-  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(2, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_find_implicants_qm, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_12canalization_21cboolean_canalization_pi_covers_fast(__pyx_v_implicant, __pyx_v_binstate, 0); if (unlikely(__pyx_t_1 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 312, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":137
+  /* "cana/canalization/cboolean_canalization.pyx":310
  * 
  * 
  * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
+ *     """Determine if a binarystate is covered by a specific implicant."""
+ *     return pi_covers_fast(implicant, binstate)
  */
-  __pyx_tuple__14 = PyTuple_Pack(4, __pyx_n_s_implicant, __pyx_n_s_binstate, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 137, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__14);
-  __Pyx_GIVEREF(__pyx_tuple__14);
-  __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_pi_covers, 137, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 137, __pyx_L1_error)
 
-  /* "cana/canalization/cboolean_canalization.pyx":149
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.__pi_covers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/canalization/cboolean_canalization.pyx":315
  * 
  * 
  * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
  *     """
  *     Expand a wildcard schemata to list all binary states it covers.
  */
-  __pyx_tuple__16 = PyTuple_Pack(8, __pyx_n_s_schemata, __pyx_n_s_nwildcards, __pyx_n_s_binary_states, __pyx_n_s_wildstatenum, __pyx_n_s_wildstates, __pyx_n_s_wnum, __pyx_n_s_newstate, __pyx_n_s_b); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 149, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__16);
-  __Pyx_GIVEREF(__pyx_tuple__16);
-  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_expand_wildcard_schemata, 149, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 149, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":181
- * 
- * 
- * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
- * 
- */
-  __pyx_tuple__18 = PyTuple_Pack(4, __pyx_n_s_prime_implicants, __pyx_n_s_pi_coverage, __pyx_n_s_pi, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 181, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__18);
-  __Pyx_GIVEREF(__pyx_tuple__18);
-  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_return_pi_coverage, 181, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 181, __pyx_L1_error)
-
-  /* "cana/canalization/cboolean_canalization.pyx":201
- * 
- * 
- * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
- * 
- */
-  __pyx_tuple__20 = PyTuple_Pack(9, __pyx_n_s_pi_coverage, __pyx_n_s_k, __pyx_n_s_input_to_wildcards, __pyx_n_s_binstate, __pyx_n_s_piset, __pyx_n_s_i, __pyx_n_s_i, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 201, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__20);
-  __Pyx_GIVEREF(__pyx_tuple__20);
-  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cboolean_canalization_pyx, __pyx_n_s_input_wildcard_coverage, 201, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 201, __pyx_L1_error)
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
-  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
-  return 0;
-  __pyx_L1_error:;
-  return -1;
-}
-
-static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
-static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
-
-static int __Pyx_modinit_global_init_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
-  /*--- Global init code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_variable_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
-  /*--- Variable export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
-static int __Pyx_modinit_function_export_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
-  /*--- Function export code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
 
-static int __Pyx_modinit_type_init_code(void) {
-  __Pyx_RefNannyDeclarations
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_19expand_wildcard_schemata(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_18expand_wildcard_schemata, "\n    Expand a wildcard schemata to list all binary states it covers.\n\n    Args:\n        schemata (string): the wildcard shemata\n    Returns:\n        binary_states (list): list of all binary states covered by the schemata\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_19expand_wildcard_schemata = {"expand_wildcard_schemata", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_19expand_wildcard_schemata, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_18expand_wildcard_schemata};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_19expand_wildcard_schemata(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_schemata = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
   int __pyx_lineno = 0;
   const char *__pyx_filename = NULL;
   int __pyx_clineno = 0;
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
-  /*--- Type init code ---*/
-  if (PyType_Ready(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers.tp_dictoffset && __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
-  }
-  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct____pi_covers;
-  if (PyType_Ready(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr.tp_print = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("expand_wildcard_schemata (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr.tp_dictoffset && __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
-  }
-  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr;
-  if (PyType_Ready(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage.tp_print = 0;
   #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage.tp_dictoffset && __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_schemata,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_schemata)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 315, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "expand_wildcard_schemata") < 0)) __PYX_ERR(0, 315, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_schemata = values[0];
   }
-  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_2_input_wildcard_coverage;
-  if (PyType_Ready(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(0, 217, __pyx_L1_error)
-  #if PY_VERSION_HEX < 0x030800B1
-  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr.tp_print = 0;
-  #endif
-  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr.tp_dictoffset && __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr.tp_getattro == PyObject_GenericGetAttr)) {
-    __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("expand_wildcard_schemata", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 315, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
   }
-  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_3_genexpr;
-  __Pyx_RefNannyFinishContext();
-  return 0;
-  __pyx_L1_error:;
-  __Pyx_RefNannyFinishContext();
-  return -1;
-}
-
-static int __Pyx_modinit_type_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
-  /*--- Type import code ---*/
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_wildcard_schemata", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
-  return 0;
-}
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_18expand_wildcard_schemata(__pyx_self, __pyx_v_schemata);
 
-static int __Pyx_modinit_variable_import_code(void) {
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
-  /*--- Variable import code ---*/
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
   __Pyx_RefNannyFinishContext();
-  return 0;
+  return __pyx_r;
 }
 
-static int __Pyx_modinit_function_import_code(void) {
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_18expand_wildcard_schemata(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_schemata) {
+  PyObject *__pyx_v_nwildcards = NULL;
+  PyObject *__pyx_v_binary_states = NULL;
+  PyObject *__pyx_v_wildstatenum = NULL;
+  PyObject *__pyx_v_wildstates = NULL;
+  PyObject *__pyx_v_wnum = NULL;
+  PyObject *__pyx_v_newstate = NULL;
+  PyObject *__pyx_v_b = NULL;
+  PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
-  /*--- Function import code ---*/
-  __Pyx_RefNannyFinishContext();
-  return 0;
-}
-
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  Py_ssize_t __pyx_t_7;
+  PyObject *(*__pyx_t_8)(PyObject *);
+  Py_ssize_t __pyx_t_9;
+  PyObject *(*__pyx_t_10)(PyObject *);
+  int __pyx_t_11;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("expand_wildcard_schemata", 1);
 
-#ifndef CYTHON_NO_PYINIT_EXPORT
-#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
-#elif PY_MAJOR_VERSION < 3
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" void
-#else
-#define __Pyx_PyMODINIT_FUNC void
-#endif
-#else
-#ifdef __cplusplus
-#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
-#else
-#define __Pyx_PyMODINIT_FUNC PyObject *
-#endif
-#endif
-
-
-#if PY_MAJOR_VERSION < 3
-__Pyx_PyMODINIT_FUNC initcboolean_canalization(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC initcboolean_canalization(void)
-#else
-__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void) CYTHON_SMALL_CODE; /*proto*/
-__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void)
-#if CYTHON_PEP489_MULTI_PHASE_INIT
-{
-  return PyModuleDef_Init(&__pyx_moduledef);
-}
-static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
-    #if PY_VERSION_HEX >= 0x030700A1
-    static PY_INT64_T main_interpreter_id = -1;
-    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
-    if (main_interpreter_id == -1) {
-        main_interpreter_id = current_id;
-        return (unlikely(current_id == -1)) ? -1 : 0;
-    } else if (unlikely(main_interpreter_id != current_id))
-    #else
-    static PyInterpreterState *main_interpreter = NULL;
-    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
-    if (!main_interpreter) {
-        main_interpreter = current_interpreter;
-    } else if (unlikely(main_interpreter != current_interpreter))
-    #endif
-    {
-        PyErr_SetString(
-            PyExc_ImportError,
-            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
-        return -1;
-    }
-    return 0;
-}
-static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) {
-    PyObject *value = PyObject_GetAttrString(spec, from_name);
-    int result = 0;
-    if (likely(value)) {
-        if (allow_none || value != Py_None) {
-            result = PyDict_SetItemString(moddict, to_name, value);
-        }
-        Py_DECREF(value);
-    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-        PyErr_Clear();
-    } else {
-        result = -1;
+  /* "cana/canalization/cboolean_canalization.pyx":326
+ * 
+ *     # count the number of wildcard symbols
+ *     nwildcards = schemata.count(WILDCARD_SYMBOL)             # <<<<<<<<<<<<<<
+ * 
+ *     # if there arent any symbols, return the original schemata
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_schemata, __pyx_n_s_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 326, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 326, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  __pyx_t_5 = 0;
+  #if CYTHON_UNPACK_METHODS
+  if (likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_5 = 1;
     }
-    return result;
-}
-static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
-    PyObject *module = NULL, *moddict, *modname;
-    if (__Pyx_check_single_interpreter())
-        return NULL;
-    if (__pyx_m)
-        return __Pyx_NewRef(__pyx_m);
-    modname = PyObject_GetAttrString(spec, "name");
-    if (unlikely(!modname)) goto bad;
-    module = PyModule_NewObject(modname);
-    Py_DECREF(modname);
-    if (unlikely(!module)) goto bad;
-    moddict = PyModule_GetDict(module);
-    if (unlikely(!moddict)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
-    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
-    return module;
-bad:
-    Py_XDECREF(module);
-    return NULL;
-}
-
-
-static CYTHON_SMALL_CODE int __pyx_pymod_exec_cboolean_canalization(PyObject *__pyx_pyinit_module)
-#endif
-#endif
-{
-  PyObject *__pyx_t_1 = NULL;
-  PyObject *__pyx_t_2 = NULL;
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-  __Pyx_RefNannyDeclarations
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  if (__pyx_m) {
-    if (__pyx_m == __pyx_pyinit_module) return 0;
-    PyErr_SetString(PyExc_RuntimeError, "Module 'cboolean_canalization' has already been imported. Re-initialisation is not supported.");
-    return -1;
   }
-  #elif PY_MAJOR_VERSION >= 3
-  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
-  #endif
-  #if CYTHON_REFNANNY
-__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
-if (!__Pyx_RefNanny) {
-  PyErr_Clear();
-  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
-  if (!__Pyx_RefNanny)
-      Py_FatalError("failed to import 'refnanny' module");
-}
-#endif
-  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void)", 0);
-  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pxy_PyFrame_Initialize_Offsets
-  __Pxy_PyFrame_Initialize_Offsets();
-  #endif
-  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #ifdef __Pyx_CyFunction_USED
-  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_FusedFunction_USED
-  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Coroutine_USED
-  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_Generator_USED
-  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_AsyncGen_USED
-  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  #ifdef __Pyx_StopAsyncIteration_USED
-  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  /*--- Library function declarations ---*/
-  /*--- Threads initialization code ---*/
-  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
-  PyEval_InitThreads();
-  #endif
-  /*--- Module creation code ---*/
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  __pyx_m = __pyx_pyinit_module;
-  Py_INCREF(__pyx_m);
-  #else
-  #if PY_MAJOR_VERSION < 3
-  __pyx_m = Py_InitModule4("cboolean_canalization", __pyx_methods, __pyx_k_Cythonized_Boolean_Canalization, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
-  #else
-  __pyx_m = PyModule_Create(&__pyx_moduledef);
-  #endif
-  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
-  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_d);
-  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_b);
-  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
-  Py_INCREF(__pyx_cython_runtime);
-  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Initialize various global constants etc. ---*/
-  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
-  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   #endif
-  if (__pyx_module_is_main_cana__canalization__cboolean_canalization) {
-    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  }
-  #if PY_MAJOR_VERSION >= 3
   {
-    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
-    if (!PyDict_GetItemString(modules, "cana.canalization.cboolean_canalization")) {
-      if (unlikely(PyDict_SetItemString(modules, "cana.canalization.cboolean_canalization", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-    }
+    PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};
+    __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);
+    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 326, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   }
-  #endif
-  /*--- Builtin init code ---*/
-  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Constants init code ---*/
-  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  /*--- Global type/function init code ---*/
-  (void)__Pyx_modinit_global_init_code();
-  (void)__Pyx_modinit_variable_export_code();
-  (void)__Pyx_modinit_function_export_code();
-  if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
-  (void)__Pyx_modinit_type_import_code();
-  (void)__Pyx_modinit_variable_import_code();
-  (void)__Pyx_modinit_function_import_code();
-  /*--- Execution code ---*/
-  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
-  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  #endif
+  __pyx_v_nwildcards = __pyx_t_1;
+  __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":15
- * #   All rights reserved.
- * #   MIT license.
- * from cana.cutils import *             # <<<<<<<<<<<<<<
+  /* "cana/canalization/cboolean_canalization.pyx":329
  * 
- * WILDCARD_SYMBOL = '#'
+ *     # if there arent any symbols, return the original schemata
+ *     if nwildcards == 0:             # <<<<<<<<<<<<<<
+ *         return [schemata]
+ *     else:
  */
-  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s__2);
-  __Pyx_GIVEREF(__pyx_n_s__2);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s__2);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_cana_cutils, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (__pyx_import_star(__pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_6 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_nwildcards, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 329, __pyx_L1_error)
+  if (__pyx_t_6) {
 
-  /* "cana/canalization/cboolean_canalization.pyx":17
- * from cana.cutils import *
- * 
- * WILDCARD_SYMBOL = '#'             # <<<<<<<<<<<<<<
- * SYMMETRIC_WILDCARD_SYMBOL = '*'
- * 
+    /* "cana/canalization/cboolean_canalization.pyx":330
+ *     # if there arent any symbols, return the original schemata
+ *     if nwildcards == 0:
+ *         return [schemata]             # <<<<<<<<<<<<<<
+ *     else:
+ *         binary_states = []
  */
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WILDCARD_SYMBOL, __pyx_kp_s__3) < 0) __PYX_ERR(0, 17, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_r);
+    __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_INCREF(__pyx_v_schemata);
+    __Pyx_GIVEREF(__pyx_v_schemata);
+    if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_schemata)) __PYX_ERR(0, 330, __pyx_L1_error);
+    __pyx_r = __pyx_t_1;
+    __pyx_t_1 = 0;
+    goto __pyx_L0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":18
- * 
- * WILDCARD_SYMBOL = '#'
- * SYMMETRIC_WILDCARD_SYMBOL = '*'             # <<<<<<<<<<<<<<
- * 
+    /* "cana/canalization/cboolean_canalization.pyx":329
  * 
+ *     # if there arent any symbols, return the original schemata
+ *     if nwildcards == 0:             # <<<<<<<<<<<<<<
+ *         return [schemata]
+ *     else:
  */
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL, __pyx_n_s__2) < 0) __PYX_ERR(0, 18, __pyx_L1_error)
+  }
 
-  /* "cana/canalization/cboolean_canalization.pyx":24
- * # Quine-McCluskey Functions
- * #
- * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
- *     """
- *     """
+  /* "cana/canalization/cboolean_canalization.pyx":332
+ *         return [schemata]
+ *     else:
+ *         binary_states = []             # <<<<<<<<<<<<<<
+ *         for wildstatenum in range(2**nwildcards):
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_1make_density_groups, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_density_groups, __pyx_t_2) < 0) __PYX_ERR(0, 24, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  /*else*/ {
+    __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 332, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_v_binary_states = ((PyObject*)__pyx_t_1);
+    __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":38
- * 
- * 
- * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
- *     """
- *     Compare two binary states and replace any differing bits by a wildcard.
+    /* "cana/canalization/cboolean_canalization.pyx":333
+ *     else:
+ *         binary_states = []
+ *         for wildstatenum in range(2**nwildcards):             # <<<<<<<<<<<<<<
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
+ *             wnum = 0
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_3find_wildcards, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_wildcards, __pyx_t_2) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
-  /* "cana/canalization/cboolean_canalization.pyx":52
- * 
- * 
- * def binary_density(binstate):             # <<<<<<<<<<<<<<
- *     """
- *     Find the density (number of 1s) for a term with possible wildcards.
+    __pyx_t_1 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_v_nwildcards, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+      __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1);
+      __pyx_t_7 = 0;
+      __pyx_t_8 = NULL;
+    } else {
+      __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 333, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_8)) {
+        if (likely(PyList_CheckExact(__pyx_t_1))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 333, __pyx_L1_error)
+            #endif
+            if (__pyx_t_7 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(0, 333, __pyx_L1_error)
+          #else
+          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          #endif
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 333, __pyx_L1_error)
+            #endif
+            if (__pyx_t_7 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(0, 333, __pyx_L1_error)
+          #else
+          __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_2);
+          #endif
+        }
+      } else {
+        __pyx_t_2 = __pyx_t_8(__pyx_t_1);
+        if (unlikely(!__pyx_t_2)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 333, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_2);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_wildstatenum, __pyx_t_2);
+      __pyx_t_2 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":334
+ *         binary_states = []
+ *         for wildstatenum in range(2**nwildcards):
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)             # <<<<<<<<<<<<<<
+ *             wnum = 0
+ *             newstate = ''
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_5binary_density, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_binary_density, __pyx_t_2) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_statenum_to_binstate); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 334, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = NULL;
+      __pyx_t_5 = 0;
+      #if CYTHON_UNPACK_METHODS
+      if (unlikely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_4)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_4);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
+          __pyx_t_5 = 1;
+        }
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_wildstatenum, __pyx_v_nwildcards};
+        __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5);
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 334, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+      __Pyx_XDECREF_SET(__pyx_v_wildstates, __pyx_t_2);
+      __pyx_t_2 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":59
- * 
- * 
- * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
- *     """
- *     Return the binary state with a wildcard at the idx position.
+      /* "cana/canalization/cboolean_canalization.pyx":335
+ *         for wildstatenum in range(2**nwildcards):
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
+ *             wnum = 0             # <<<<<<<<<<<<<<
+ *             newstate = ''
+ *             for b in schemata:
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_7replace_wildcard, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_replace_wildcard, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_INCREF(__pyx_int_0);
+      __Pyx_XDECREF_SET(__pyx_v_wnum, __pyx_int_0);
 
-  /* "cana/canalization/cboolean_canalization.pyx":66
- * 
- * 
- * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
- *     """ Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.
+      /* "cana/canalization/cboolean_canalization.pyx":336
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
+ *             wnum = 0
+ *             newstate = ''             # <<<<<<<<<<<<<<
+ *             for b in schemata:
+ *                 if b == WILDCARD_SYMBOL:
+ */
+      __Pyx_INCREF(__pyx_kp_u_);
+      __Pyx_XDECREF_SET(__pyx_v_newstate, __pyx_kp_u_);
+
+      /* "cana/canalization/cboolean_canalization.pyx":337
+ *             wnum = 0
+ *             newstate = ''
+ *             for b in schemata:             # <<<<<<<<<<<<<<
+ *                 if b == WILDCARD_SYMBOL:
+ *                     newstate += wildstates[wnum]
+ */
+      if (likely(PyList_CheckExact(__pyx_v_schemata)) || PyTuple_CheckExact(__pyx_v_schemata)) {
+        __pyx_t_2 = __pyx_v_schemata; __Pyx_INCREF(__pyx_t_2);
+        __pyx_t_9 = 0;
+        __pyx_t_10 = NULL;
+      } else {
+        __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_schemata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_2);
+        __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 337, __pyx_L1_error)
+      }
+      for (;;) {
+        if (likely(!__pyx_t_10)) {
+          if (likely(PyList_CheckExact(__pyx_t_2))) {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 337, __pyx_L1_error)
+              #endif
+              if (__pyx_t_9 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(0, 337, __pyx_L1_error)
+            #else
+            __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            #endif
+          } else {
+            {
+              Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2);
+              #if !CYTHON_ASSUME_SAFE_MACROS
+              if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 337, __pyx_L1_error)
+              #endif
+              if (__pyx_t_9 >= __pyx_temp) break;
+            }
+            #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+            __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(0, 337, __pyx_L1_error)
+            #else
+            __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error)
+            __Pyx_GOTREF(__pyx_t_3);
+            #endif
+          }
+        } else {
+          __pyx_t_3 = __pyx_t_10(__pyx_t_2);
+          if (unlikely(!__pyx_t_3)) {
+            PyObject* exc_type = PyErr_Occurred();
+            if (exc_type) {
+              if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+              else __PYX_ERR(0, 337, __pyx_L1_error)
+            }
+            break;
+          }
+          __Pyx_GOTREF(__pyx_t_3);
+        }
+        __Pyx_XDECREF_SET(__pyx_v_b, __pyx_t_3);
+        __pyx_t_3 = 0;
+
+        /* "cana/canalization/cboolean_canalization.pyx":338
+ *             newstate = ''
+ *             for b in schemata:
+ *                 if b == WILDCARD_SYMBOL:             # <<<<<<<<<<<<<<
+ *                     newstate += wildstates[wnum]
+ *                     wnum += 1
+ */
+        __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = PyObject_RichCompare(__pyx_v_b, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 338, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 338, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        if (__pyx_t_6) {
+
+          /* "cana/canalization/cboolean_canalization.pyx":339
+ *             for b in schemata:
+ *                 if b == WILDCARD_SYMBOL:
+ *                     newstate += wildstates[wnum]             # <<<<<<<<<<<<<<
+ *                     wnum += 1
+ *                 else:
+ */
+          __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_wildstates, __pyx_v_wnum); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 339, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_newstate, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 339, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+          __Pyx_DECREF_SET(__pyx_v_newstate, __pyx_t_3);
+          __pyx_t_3 = 0;
+
+          /* "cana/canalization/cboolean_canalization.pyx":340
+ *                 if b == WILDCARD_SYMBOL:
+ *                     newstate += wildstates[wnum]
+ *                     wnum += 1             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     newstate += b
+ */
+          __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_wnum, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF_SET(__pyx_v_wnum, __pyx_t_3);
+          __pyx_t_3 = 0;
+
+          /* "cana/canalization/cboolean_canalization.pyx":338
+ *             newstate = ''
+ *             for b in schemata:
+ *                 if b == WILDCARD_SYMBOL:             # <<<<<<<<<<<<<<
+ *                     newstate += wildstates[wnum]
+ *                     wnum += 1
+ */
+          goto __pyx_L8;
+        }
+
+        /* "cana/canalization/cboolean_canalization.pyx":342
+ *                     wnum += 1
+ *                 else:
+ *                     newstate += b             # <<<<<<<<<<<<<<
+ *             binary_states.append(newstate)
+ *         return binary_states
+ */
+        /*else*/ {
+          __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_newstate, __pyx_v_b); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 342, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_3);
+          __Pyx_DECREF_SET(__pyx_v_newstate, __pyx_t_3);
+          __pyx_t_3 = 0;
+        }
+        __pyx_L8:;
+
+        /* "cana/canalization/cboolean_canalization.pyx":337
+ *             wnum = 0
+ *             newstate = ''
+ *             for b in schemata:             # <<<<<<<<<<<<<<
+ *                 if b == WILDCARD_SYMBOL:
+ *                     newstate += wildstates[wnum]
+ */
+      }
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":343
+ *                 else:
+ *                     newstate += b
+ *             binary_states.append(newstate)             # <<<<<<<<<<<<<<
+ *         return binary_states
  * 
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_9find_implicants_qm, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_implicants_qm, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_binary_states, __pyx_v_newstate); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 343, __pyx_L1_error)
+
+      /* "cana/canalization/cboolean_canalization.pyx":333
+ *     else:
+ *         binary_states = []
+ *         for wildstatenum in range(2**nwildcards):             # <<<<<<<<<<<<<<
+ *             wildstates = statenum_to_binstate(wildstatenum, nwildcards)
+ *             wnum = 0
+ */
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":137
+    /* "cana/canalization/cboolean_canalization.pyx":344
+ *                     newstate += b
+ *             binary_states.append(newstate)
+ *         return binary_states             # <<<<<<<<<<<<<<
  * 
  * 
- * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
- *     """Determines if a binarystate is covered by a specific implicant.
- *     Args:
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_11__pi_covers, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pi_covers, __pyx_t_2) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(__pyx_v_binary_states);
+    __pyx_r = __pyx_v_binary_states;
+    goto __pyx_L0;
+  }
 
-  /* "cana/canalization/cboolean_canalization.pyx":149
+  /* "cana/canalization/cboolean_canalization.pyx":315
  * 
  * 
  * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
  *     """
  *     Expand a wildcard schemata to list all binary states it covers.
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_13expand_wildcard_schemata, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_expand_wildcard_schemata, __pyx_t_2) < 0) __PYX_ERR(0, 149, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":181
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.expand_wildcard_schemata", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_nwildcards);
+  __Pyx_XDECREF(__pyx_v_binary_states);
+  __Pyx_XDECREF(__pyx_v_wildstatenum);
+  __Pyx_XDECREF(__pyx_v_wildstates);
+  __Pyx_XDECREF(__pyx_v_wnum);
+  __Pyx_XDECREF(__pyx_v_newstate);
+  __Pyx_XDECREF(__pyx_v_b);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/canalization/cboolean_canalization.pyx":347
  * 
  * 
  * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
  *     """Computes the binary states coverage by Prime Implicant schematas.
  * 
  */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_15return_pi_coverage, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_return_pi_coverage, __pyx_t_2) < 0) __PYX_ERR(0, 181, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
-  /* "cana/canalization/cboolean_canalization.pyx":201
- * 
- * 
- * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
- *     """Computes the binary states coverage by Prime Implicant schematas.
- * 
- */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_17input_wildcard_coverage, NULL, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_input_wildcard_coverage, __pyx_t_2) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_21return_pi_coverage(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_20return_pi_coverage, "Computes the binary states coverage by Prime Implicant schematas.\n\n    Args:\n        prime_implicants (set): a set of prime implicants.\n            This is returned by `find_implicants_qm`.\n    Returns:\n        pi_coverage (dict) : a dictionary of coverage where keys are input states and values are lists of the Prime Implicants covering that input.\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_21return_pi_coverage = {"return_pi_coverage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_21return_pi_coverage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_20return_pi_coverage};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_21return_pi_coverage(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_prime_implicants = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("return_pi_coverage (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prime_implicants,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_prime_implicants)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 347, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "return_pi_coverage") < 0)) __PYX_ERR(0, 347, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_prime_implicants = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("return_pi_coverage", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 347, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.return_pi_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_20return_pi_coverage(__pyx_self, __pyx_v_prime_implicants);
 
-  /* "cana/canalization/cboolean_canalization.pyx":1
- * # -*- coding: utf-8 -*-             # <<<<<<<<<<<<<<
- * """
- * (Cythonized) Boolean Canalization
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_20return_pi_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_prime_implicants) {
+  PyObject *__pyx_v_pi_coverage = NULL;
+  PyObject *__pyx_v_pi = NULL;
+  PyObject *__pyx_v_binstate = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *(*__pyx_t_3)(PyObject *);
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  PyObject *(*__pyx_t_9)(PyObject *);
+  int __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("return_pi_coverage", 1);
+
+  /* "cana/canalization/cboolean_canalization.pyx":357
+ *     """
+ * 
+ *     pi_coverage = dict()             # <<<<<<<<<<<<<<
+ *     for pi in prime_implicants:
+ *         for binstate in expand_wildcard_schemata(pi):
  */
-  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pi_coverage = ((PyObject*)__pyx_t_1);
+  __pyx_t_1 = 0;
 
-  /*--- Wrapped vars code ---*/
+  /* "cana/canalization/cboolean_canalization.pyx":358
+ * 
+ *     pi_coverage = dict()
+ *     for pi in prime_implicants:             # <<<<<<<<<<<<<<
+ *         for binstate in expand_wildcard_schemata(pi):
+ *             if binstate not in pi_coverage:
+ */
+  if (likely(PyList_CheckExact(__pyx_v_prime_implicants)) || PyTuple_CheckExact(__pyx_v_prime_implicants)) {
+    __pyx_t_1 = __pyx_v_prime_implicants; __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = NULL;
+  } else {
+    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_prime_implicants); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 358, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_3)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 358, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 358, __pyx_L1_error)
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 358, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 358, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 358, __pyx_L1_error)
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 358, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      }
+    } else {
+      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
+      if (unlikely(!__pyx_t_4)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 358, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_pi, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":359
+ *     pi_coverage = dict()
+ *     for pi in prime_implicants:
+ *         for binstate in expand_wildcard_schemata(pi):             # <<<<<<<<<<<<<<
+ *             if binstate not in pi_coverage:
+ *                 pi_coverage[binstate] = set()
+ */
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_expand_wildcard_schemata); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = NULL;
+    __pyx_t_7 = 0;
+    #if CYTHON_UNPACK_METHODS
+    if (unlikely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_6)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_6);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+        __pyx_t_7 = 1;
+      }
+    }
+    #endif
+    {
+      PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_pi};
+      __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+      __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 359, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+    if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
+      __pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5);
+      __pyx_t_8 = 0;
+      __pyx_t_9 = NULL;
+    } else {
+      __pyx_t_8 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 359, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 359, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    for (;;) {
+      if (likely(!__pyx_t_9)) {
+        if (likely(PyList_CheckExact(__pyx_t_5))) {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 359, __pyx_L1_error)
+            #endif
+            if (__pyx_t_8 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_4); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 359, __pyx_L1_error)
+          #else
+          __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 359, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          #endif
+        } else {
+          {
+            Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5);
+            #if !CYTHON_ASSUME_SAFE_MACROS
+            if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 359, __pyx_L1_error)
+            #endif
+            if (__pyx_t_8 >= __pyx_temp) break;
+          }
+          #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+          __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_4); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(0, 359, __pyx_L1_error)
+          #else
+          __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 359, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_4);
+          #endif
+        }
+      } else {
+        __pyx_t_4 = __pyx_t_9(__pyx_t_5);
+        if (unlikely(!__pyx_t_4)) {
+          PyObject* exc_type = PyErr_Occurred();
+          if (exc_type) {
+            if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+            else __PYX_ERR(0, 359, __pyx_L1_error)
+          }
+          break;
+        }
+        __Pyx_GOTREF(__pyx_t_4);
+      }
+      __Pyx_XDECREF_SET(__pyx_v_binstate, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":360
+ *     for pi in prime_implicants:
+ *         for binstate in expand_wildcard_schemata(pi):
+ *             if binstate not in pi_coverage:             # <<<<<<<<<<<<<<
+ *                 pi_coverage[binstate] = set()
+ *             pi_coverage[binstate].add(pi)
+ */
+      __pyx_t_10 = (__Pyx_PyDict_ContainsTF(__pyx_v_binstate, __pyx_v_pi_coverage, Py_NE)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 360, __pyx_L1_error)
+      if (__pyx_t_10) {
+
+        /* "cana/canalization/cboolean_canalization.pyx":361
+ *         for binstate in expand_wildcard_schemata(pi):
+ *             if binstate not in pi_coverage:
+ *                 pi_coverage[binstate] = set()             # <<<<<<<<<<<<<<
+ *             pi_coverage[binstate].add(pi)
+ * 
+ */
+        __pyx_t_4 = PySet_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 361, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        if (unlikely((PyDict_SetItem(__pyx_v_pi_coverage, __pyx_v_binstate, __pyx_t_4) < 0))) __PYX_ERR(0, 361, __pyx_L1_error)
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+        /* "cana/canalization/cboolean_canalization.pyx":360
+ *     for pi in prime_implicants:
+ *         for binstate in expand_wildcard_schemata(pi):
+ *             if binstate not in pi_coverage:             # <<<<<<<<<<<<<<
+ *                 pi_coverage[binstate] = set()
+ *             pi_coverage[binstate].add(pi)
+ */
+      }
+
+      /* "cana/canalization/cboolean_canalization.pyx":362
+ *             if binstate not in pi_coverage:
+ *                 pi_coverage[binstate] = set()
+ *             pi_coverage[binstate].add(pi)             # <<<<<<<<<<<<<<
+ * 
+ *     return pi_coverage
+ */
+      __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_pi_coverage, __pyx_v_binstate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 362, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_add); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 362, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_6 = NULL;
+      __pyx_t_7 = 0;
+      #if CYTHON_UNPACK_METHODS
+      if (likely(PyMethod_Check(__pyx_t_11))) {
+        __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11);
+        if (likely(__pyx_t_6)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+          __Pyx_INCREF(__pyx_t_6);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_11, function);
+          __pyx_t_7 = 1;
+        }
+      }
+      #endif
+      {
+        PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_pi};
+        __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7);
+        __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+        if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 362, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+      /* "cana/canalization/cboolean_canalization.pyx":359
+ *     pi_coverage = dict()
+ *     for pi in prime_implicants:
+ *         for binstate in expand_wildcard_schemata(pi):             # <<<<<<<<<<<<<<
+ *             if binstate not in pi_coverage:
+ *                 pi_coverage[binstate] = set()
+ */
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":358
+ * 
+ *     pi_coverage = dict()
+ *     for pi in prime_implicants:             # <<<<<<<<<<<<<<
+ *         for binstate in expand_wildcard_schemata(pi):
+ *             if binstate not in pi_coverage:
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":364
+ *             pi_coverage[binstate].add(pi)
+ * 
+ *     return pi_coverage             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_pi_coverage);
+  __pyx_r = __pyx_v_pi_coverage;
+  goto __pyx_L0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":347
+ * 
+ * 
+ * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.return_pi_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_pi_coverage);
+  __Pyx_XDECREF(__pyx_v_pi);
+  __Pyx_XDECREF(__pyx_v_binstate);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/canalization/cboolean_canalization.pyx":367
+ * 
+ * 
+ * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_12canalization_21cboolean_canalization_22input_wildcard_coverage, "Computes the binary states coverage by Prime Implicant schematas.\n\n    Args:\n        pi_coverage (dict): a dict mapping binary states to their prime implicants.\n            This is returned by `return_pi_coverage`.\n    Returns:\n        input_wildcard_coverage (dict) : a dictionary of coverage where keys are inputs and values are lists of wither a WildCard covers that input.\n\n    ");
+static PyMethodDef __pyx_mdef_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage = {"input_wildcard_coverage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_12canalization_21cboolean_canalization_22input_wildcard_coverage};
+static PyObject *__pyx_pw_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_pi_coverage = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("input_wildcard_coverage (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_MACROS
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pi_coverage,0};
+    if (__pyx_kwds) {
+      Py_ssize_t kw_args;
+      switch (__pyx_nargs) {
+        case  1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds);
+      switch (__pyx_nargs) {
+        case  0:
+        if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pi_coverage)) != 0)) {
+          (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
+          kw_args--;
+        }
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 367, __pyx_L3_error)
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        const Py_ssize_t kwd_pos_args = __pyx_nargs;
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "input_wildcard_coverage") < 0)) __PYX_ERR(0, 367, __pyx_L3_error)
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0);
+    }
+    __pyx_v_pi_coverage = values[0];
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("input_wildcard_coverage", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 367, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.input_wildcard_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4cana_12canalization_21cboolean_canalization_22input_wildcard_coverage(__pyx_self, __pyx_v_pi_coverage);
+
+  /* function exit code */
+  {
+    Py_ssize_t __pyx_temp;
+    for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+      __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]);
+    }
+  }
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */
+
+/* "cana/canalization/cboolean_canalization.pyx":383
+ *     for binstate, piset in pi_coverage.items():
+ *         for i in range(k):
+ *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)             # <<<<<<<<<<<<<<
+ * 
+ *     return input_to_wildcards
+ */
+
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) {
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_cur_scope;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 383, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
+  }
+  __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *) __pyx_self;
+  __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
+  __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope);
+  __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0;
+  __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
+  __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0);
+  {
+    __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_input_wildcard_coverage_locals_g, __pyx_n_s_cana_canalization_cboolean_canal); if (unlikely(!gen)) __PYX_ERR(0, 383, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_cur_scope);
+    __Pyx_RefNannyFinishContext();
+    return (PyObject *) gen;
+  }
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.input_wildcard_coverage.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */
+{
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)__pyx_generator->closure);
+  PyObject *__pyx_r = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *(*__pyx_t_3)(PyObject *);
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("genexpr", 0);
+  switch (__pyx_generator->resume_label) {
+    case 0: goto __pyx_L3_first_run;
+    case 1: goto __pyx_L6_resume_from_yield;
+    default: /* CPython raises the right error here */
+    __Pyx_RefNannyFinishContext();
+    return NULL;
+  }
+  __pyx_L3_first_run:;
+  if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 383, __pyx_L1_error)
+  if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 383, __pyx_L1_error) }
+  if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) {
+    __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1);
+    __pyx_t_2 = 0;
+    __pyx_t_3 = NULL;
+  } else {
+    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 383, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_3)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 383, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 383, __pyx_L1_error)
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 383, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      } else {
+        {
+          Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1);
+          #if !CYTHON_ASSUME_SAFE_MACROS
+          if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 383, __pyx_L1_error)
+          #endif
+          if (__pyx_t_2 >= __pyx_temp) break;
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(0, 383, __pyx_L1_error)
+        #else
+        __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 383, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      }
+    } else {
+      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
+      if (unlikely(!__pyx_t_4)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(0, 383, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_pi);
+    __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_pi, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_pi, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 383, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_WILDCARD_SYMBOL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 383, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 383, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_r = __pyx_t_6;
+    __pyx_t_6 = 0;
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __pyx_cur_scope->__pyx_t_0 = __pyx_t_1;
+    __pyx_cur_scope->__pyx_t_1 = __pyx_t_2;
+    __pyx_cur_scope->__pyx_t_2 = __pyx_t_3;
+    __Pyx_XGIVEREF(__pyx_r);
+    __Pyx_RefNannyFinishContext();
+    __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+    /* return from generator, yielding value */
+    __pyx_generator->resume_label = 1;
+    return __pyx_r;
+    __pyx_L6_resume_from_yield:;
+    __pyx_t_1 = __pyx_cur_scope->__pyx_t_0;
+    __pyx_cur_scope->__pyx_t_0 = 0;
+    __Pyx_XGOTREF(__pyx_t_1);
+    __pyx_t_2 = __pyx_cur_scope->__pyx_t_1;
+    __pyx_t_3 = __pyx_cur_scope->__pyx_t_2;
+    if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 383, __pyx_L1_error)
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
+
+  /* function exit code */
+  PyErr_SetNone(PyExc_StopIteration);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_Generator_Replace_StopIteration(0);
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_r); __pyx_r = 0;
+  #if !CYTHON_USE_EXC_INFO_STACK
+  __Pyx_Coroutine_ResetAndClearException(__pyx_generator);
+  #endif
+  __pyx_generator->resume_label = -1;
+  __Pyx_Coroutine_clear((PyObject*)__pyx_generator);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/canalization/cboolean_canalization.pyx":367
+ * 
+ * 
+ * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+
+static PyObject *__pyx_pf_4cana_12canalization_21cboolean_canalization_22input_wildcard_coverage(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pi_coverage) {
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *__pyx_cur_scope;
+  Py_ssize_t __pyx_v_k;
+  PyObject *__pyx_v_input_to_wildcards = NULL;
+  PyObject *__pyx_v_binstate = NULL;
+  PyObject *__pyx_v_piset = NULL;
+  Py_ssize_t __pyx_8genexpr5__pyx_v_i;
+  PyObject *__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  Py_ssize_t __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  PyObject *__pyx_t_11 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("input_wildcard_coverage", 0);
+  __pyx_cur_scope = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage, __pyx_empty_tuple, NULL);
+  if (unlikely(!__pyx_cur_scope)) {
+    __pyx_cur_scope = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *)Py_None);
+    __Pyx_INCREF(Py_None);
+    __PYX_ERR(0, 367, __pyx_L1_error)
+  } else {
+    __Pyx_GOTREF((PyObject *)__pyx_cur_scope);
+  }
+
+  /* "cana/canalization/cboolean_canalization.pyx":378
+ *     """
+ *     # number of inputs
+ *     k = len(next(iter(pi_coverage)))             # <<<<<<<<<<<<<<
+ * 
+ *     input_to_wildcards = {i: dict() for i in range(k)}
+ */
+  __pyx_t_1 = PyObject_GetIter(__pyx_v_pi_coverage); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyIter_Next(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 378, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_k = __pyx_t_3;
+
+  /* "cana/canalization/cboolean_canalization.pyx":380
+ *     k = len(next(iter(pi_coverage)))
+ * 
+ *     input_to_wildcards = {i: dict() for i in range(k)}             # <<<<<<<<<<<<<<
+ *     for binstate, piset in pi_coverage.items():
+ *         for i in range(k):
+ */
+  { /* enter inner scope */
+    __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __pyx_v_k;
+    __pyx_t_4 = __pyx_t_3;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_8genexpr5__pyx_v_i = __pyx_t_5;
+      __pyx_t_1 = PyInt_FromSsize_t(__pyx_8genexpr5__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_t_1, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 380, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  } /* exit inner scope */
+  __pyx_v_input_to_wildcards = ((PyObject*)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":381
+ * 
+ *     input_to_wildcards = {i: dict() for i in range(k)}
+ *     for binstate, piset in pi_coverage.items():             # <<<<<<<<<<<<<<
+ *         for i in range(k):
+ *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+ */
+  __pyx_t_3 = 0;
+  if (unlikely(__pyx_v_pi_coverage == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items");
+    __PYX_ERR(0, 381, __pyx_L1_error)
+  }
+  __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_pi_coverage, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_7)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_2);
+  __pyx_t_2 = __pyx_t_6;
+  __pyx_t_6 = 0;
+  while (1) {
+    __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, &__pyx_t_1, NULL, __pyx_t_7);
+    if (unlikely(__pyx_t_8 == 0)) break;
+    if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 381, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_XDECREF_SET(__pyx_v_binstate, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_piset, __pyx_t_1);
+    __pyx_t_1 = 0;
+
+    /* "cana/canalization/cboolean_canalization.pyx":382
+ *     input_to_wildcards = {i: dict() for i in range(k)}
+ *     for binstate, piset in pi_coverage.items():
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+ * 
+ */
+    __pyx_t_5 = __pyx_v_k;
+    __pyx_t_9 = __pyx_t_5;
+    for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+      __pyx_cur_scope->__pyx_v_i = __pyx_t_10;
+
+      /* "cana/canalization/cboolean_canalization.pyx":383
+ *     for binstate, piset in pi_coverage.items():
+ *         for i in range(k):
+ *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)             # <<<<<<<<<<<<<<
+ * 
+ *     return input_to_wildcards
+ */
+      __pyx_t_1 = __pyx_pf_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_piset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_6 = __Pyx_PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 383, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_1 = PyInt_FromSsize_t(__pyx_cur_scope->__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_11 = __Pyx_PyDict_GetItem(__pyx_v_input_to_wildcards, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 383, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      if (unlikely((PyObject_SetItem(__pyx_t_11, __pyx_v_binstate, __pyx_t_6) < 0))) __PYX_ERR(0, 383, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":385
+ *             input_to_wildcards[i][binstate] = tuple(pi[i] == WILDCARD_SYMBOL for pi in piset)
+ * 
+ *     return input_to_wildcards             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(__pyx_v_input_to_wildcards);
+  __pyx_r = __pyx_v_input_to_wildcards;
+  goto __pyx_L0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":367
+ * 
+ * 
+ * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_AddTraceback("cana.canalization.cboolean_canalization.input_wildcard_coverage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_input_to_wildcards);
+  __Pyx_XDECREF(__pyx_v_binstate);
+  __Pyx_XDECREF(__pyx_v_piset);
+  __Pyx_XDECREF(__pyx_gb_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage_2generator);
+  __Pyx_DECREF((PyObject *)__pyx_cur_scope);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+#if CYTHON_USE_FREELISTS
+static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage[8];
+static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage = 0;
+#endif
+
+static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  #if CYTHON_USE_FREELISTS
+  if (likely((int)(__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage)))) {
+    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage];
+    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage));
+    (void) PyObject_INIT(o, t);
+  } else
+  #endif
+  {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  #endif
+  return o;
+}
+
+static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage(PyObject *o) {
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
+  #if CYTHON_USE_FREELISTS
+  if (((int)(__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage)))) {
+    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage *)o);
+  } else
+  #endif
+  {
+    #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+    (*Py_TYPE(o)->tp_free)(o);
+    #else
+    {
+      freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+      if (tp_free) tp_free(o);
+    }
+    #endif
+  }
+}
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage},
+  {Py_tp_new, (void *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage_spec = {
+  "cana.canalization.cboolean_canalization.__pyx_scope_struct__input_wildcard_coverage",
+  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_FINALIZE,
+  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage_slots,
+};
+#else
+
+static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "cana.canalization.cboolean_canalization.""__pyx_scope_struct__input_wildcard_coverage", /*tp_name*/
+  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
+  0, /*tp_dictoffset*/
+  #endif
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
+  0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+  0, /*tp_vectorcall*/
+  #endif
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+  0, /*tp_pypy_flags*/
+  #endif
+};
+#endif
+
+#if CYTHON_USE_FREELISTS
+static struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[8];
+static int __pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = 0;
+#endif
+
+static PyObject *__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc);
+  o = alloc_func(t, 0);
+  #else
+  #if CYTHON_USE_FREELISTS
+  if (likely((int)(__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr)))) {
+    o = (PyObject*)__pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[--__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr];
+    memset(o, 0, sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr));
+    (void) PyObject_INIT(o, t);
+    PyObject_GC_Track(o);
+  } else
+  #endif
+  {
+    o = (*t->tp_alloc)(t, 0);
+    if (unlikely(!o)) return 0;
+  }
+  #endif
+  return o;
+}
+
+static void __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyObject *o) {
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o;
+  #if CYTHON_USE_TP_FINALIZE
+  if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) {
+    if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr) {
+      if (PyObject_CallFinalizerFromDealloc(o)) return;
+    }
+  }
+  #endif
+  PyObject_GC_UnTrack(o);
+  Py_CLEAR(p->__pyx_outer_scope);
+  Py_CLEAR(p->__pyx_genexpr_arg_0);
+  Py_CLEAR(p->__pyx_v_pi);
+  Py_CLEAR(p->__pyx_t_0);
+  #if CYTHON_USE_FREELISTS
+  if (((int)(__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr)))) {
+    __pyx_freelist_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr[__pyx_freecount_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o);
+  } else
+  #endif
+  {
+    #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+    (*Py_TYPE(o)->tp_free)(o);
+    #else
+    {
+      freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free);
+      if (tp_free) tp_free(o);
+    }
+    #endif
+  }
+}
+
+static int __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) {
+  int e;
+  struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr *)o;
+  if (p->__pyx_outer_scope) {
+    e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e;
+  }
+  if (p->__pyx_genexpr_arg_0) {
+    e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e;
+  }
+  if (p->__pyx_v_pi) {
+    e = (*v)(p->__pyx_v_pi, a); if (e) return e;
+  }
+  if (p->__pyx_t_0) {
+    e = (*v)(p->__pyx_t_0, a); if (e) return e;
+  }
+  return 0;
+}
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr_slots[] = {
+  {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr},
+  {Py_tp_traverse, (void *)__pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr},
+  {Py_tp_new, (void *)__pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr},
+  {0, 0},
+};
+static PyType_Spec __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr_spec = {
+  "cana.canalization.cboolean_canalization.__pyx_scope_struct_1_genexpr",
+  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr),
+  0,
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE,
+  __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr_slots,
+};
+#else
+
+static PyTypeObject __pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "cana.canalization.cboolean_canalization.""__pyx_scope_struct_1_genexpr", /*tp_name*/
+  sizeof(struct __pyx_obj_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_dealloc*/
+  #if PY_VERSION_HEX < 0x030800b4
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b4
+  0, /*tp_vectorcall_offset*/
+  #endif
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+  0, /*tp_doc*/
+  __pyx_tp_traverse_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  #if !CYTHON_USE_TYPE_SPECS
+  0, /*tp_dictoffset*/
+  #endif
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  #if CYTHON_USE_TP_FINALIZE
+  0, /*tp_finalize*/
+  #else
+  NULL, /*tp_finalize*/
+  #endif
+  #endif
+  #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+  0, /*tp_vectorcall*/
+  #endif
+  #if __PYX_NEED_TP_PRINT_SLOT == 1
+  0, /*tp_print*/
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000
+  0, /*tp_watched*/
+  #endif
+  #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+  0, /*tp_pypy_flags*/
+  #endif
+};
+#endif
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+
+static int __pyx_import_star_set(PyObject *o, PyObject* py_name, char *name) {
+  static const char* internal_type_names[] = {
+    "__pyx_ctuple_Py_ssize_t",
+    "__pyx_ctuple_Py_ssize_t__and_Py_ssize_t",
+    "__pyx_ctuple_Py_ssize_t__and_Py_ssize_t_struct",
+    "__pyx_ctuple_Py_ssize_t_struct",
+    "__pyx_scope_struct_1_genexpr",
+    "__pyx_scope_struct__input_wildcard_coverage",
+    0
+  };
+  const char** type_name = internal_type_names;
+  while (*type_name) {
+    if (__Pyx_StrEq(name, *type_name)) {
+      PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);
+      goto bad;
+    }
+    type_name++;
+  }
+  if (0);
+  else {
+    if (PyObject_SetAttr(__pyx_m, py_name, o) < 0) goto bad;
+  }
+  return 0;
+  bad:
+  return -1;
+}
+
+static int
+__Pyx_import_all_from(PyObject *locals, PyObject *v)
+{
+    PyObject *all = PyObject_GetAttrString(v, "__all__");
+    PyObject *dict, *name, *value;
+    int skip_leading_underscores = 0;
+    int pos, err;
+    if (all == NULL) {
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+            return -1;
+        PyErr_Clear();
+        dict = PyObject_GetAttrString(v, "__dict__");
+        if (dict == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+                return -1;
+            PyErr_SetString(PyExc_ImportError,
+            "from-import-* object has no __dict__ and no __all__");
+            return -1;
+        }
+#if PY_MAJOR_VERSION < 3
+        all = PyObject_CallMethod(dict, (char *)"keys", NULL);
+#else
+        all = PyMapping_Keys(dict);
+#endif
+        Py_DECREF(dict);
+        if (all == NULL)
+            return -1;
+        skip_leading_underscores = 1;
+    }
+    for (pos = 0, err = 0; ; pos++) {
+        name = PySequence_GetItem(all, pos);
+        if (name == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_IndexError))
+                err = -1;
+            else
+                PyErr_Clear();
+            break;
+        }
+        if (skip_leading_underscores &&
+#if PY_MAJOR_VERSION < 3
+            likely(PyString_Check(name)) &&
+            PyString_AS_STRING(name)[0] == '_')
+#else
+            likely(PyUnicode_Check(name)) &&
+            likely(__Pyx_PyUnicode_GET_LENGTH(name)) &&
+            __Pyx_PyUnicode_READ_CHAR(name, 0) == '_')
+#endif
+        {
+            Py_DECREF(name);
+            continue;
+        }
+        value = PyObject_GetAttr(v, name);
+        if (value == NULL)
+            err = -1;
+        else if (PyDict_CheckExact(locals))
+            err = PyDict_SetItem(locals, name, value);
+        else
+            err = PyObject_SetItem(locals, name, value);
+        Py_DECREF(name);
+        Py_XDECREF(value);
+        if (err != 0)
+            break;
+    }
+    Py_DECREF(all);
+    return err;
+}
+static int __pyx_import_star(PyObject* m) {
+    int i;
+    int ret = -1;
+    char* s;
+    PyObject *locals = 0;
+    PyObject *list = 0;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *utf8_name = 0;
+#endif
+    PyObject *name;
+    PyObject *item;
+    locals = PyDict_New();              if (!locals) goto bad;
+    if (__Pyx_import_all_from(locals, m) < 0) goto bad;
+    list = PyDict_Items(locals);        if (!list) goto bad;
+    for(i=0; i<PyList_GET_SIZE(list); i++) {
+        name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0);
+        item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1);
+#if PY_MAJOR_VERSION >= 3
+        utf8_name = PyUnicode_AsUTF8String(name);
+        if (!utf8_name) goto bad;
+        s = PyBytes_AS_STRING(utf8_name);
+        if (__pyx_import_star_set(item, name, s) < 0) goto bad;
+        Py_DECREF(utf8_name); utf8_name = 0;
+#else
+        s = PyString_AsString(name);
+        if (!s) goto bad;
+        if (__pyx_import_star_set(item, name, s) < 0) goto bad;
+#endif
+    }
+    ret = 0;
+bad:
+    Py_XDECREF(locals);
+    Py_XDECREF(list);
+#if PY_MAJOR_VERSION >= 3
+    Py_XDECREF(utf8_name);
+#endif
+    return ret;
+}
+
+
+#ifndef CYTHON_SMALL_CODE
+#if defined(__clang__)
+    #define CYTHON_SMALL_CODE
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+/* #### Code section: pystring_table ### */
+
+static int __Pyx_CreateStringTabAndInitStrings(void) {
+  __Pyx_StringTabEntry __pyx_string_tab[] = {
+    {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0},
+    {&__pyx_kp_u_0, __pyx_k_0, sizeof(__pyx_k_0), 0, 1, 0, 0},
+    {&__pyx_kp_u_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 1, 0, 0},
+    {&__pyx_kp_u_2, __pyx_k_2, sizeof(__pyx_k_2), 0, 1, 0, 0},
+    {&__pyx_kp_u_Implicant_and_binstate_must_have, __pyx_k_Implicant_and_binstate_must_have, sizeof(__pyx_k_Implicant_and_binstate_must_have), 0, 1, 0, 0},
+    {&__pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL, __pyx_k_SYMMETRIC_WILDCARD_SYMBOL, sizeof(__pyx_k_SYMMETRIC_WILDCARD_SYMBOL), 0, 0, 1, 1},
+    {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+    {&__pyx_n_s_WILDCARD_SYMBOL, __pyx_k_WILDCARD_SYMBOL, sizeof(__pyx_k_WILDCARD_SYMBOL), 0, 0, 1, 1},
+    {&__pyx_n_s__29, __pyx_k__29, sizeof(__pyx_k__29), 0, 0, 1, 1},
+    {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1},
+    {&__pyx_kp_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0, 0},
+    {&__pyx_kp_u__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 1, 0, 0},
+    {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
+    {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
+    {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1},
+    {&__pyx_n_s_b, __pyx_k_b, sizeof(__pyx_k_b), 0, 0, 1, 1},
+    {&__pyx_n_s_b0, __pyx_k_b0, sizeof(__pyx_k_b0), 0, 0, 1, 1},
+    {&__pyx_n_s_b1, __pyx_k_b1, sizeof(__pyx_k_b1), 0, 0, 1, 1},
+    {&__pyx_n_s_binary_density, __pyx_k_binary_density, sizeof(__pyx_k_binary_density), 0, 0, 1, 1},
+    {&__pyx_n_s_binary_states, __pyx_k_binary_states, sizeof(__pyx_k_binary_states), 0, 0, 1, 1},
+    {&__pyx_n_s_binstate, __pyx_k_binstate, sizeof(__pyx_k_binstate), 0, 0, 1, 1},
+    {&__pyx_n_s_binstate0, __pyx_k_binstate0, sizeof(__pyx_k_binstate0), 0, 0, 1, 1},
+    {&__pyx_n_s_binstate1, __pyx_k_binstate1, sizeof(__pyx_k_binstate1), 0, 0, 1, 1},
+    {&__pyx_n_s_binstate2, __pyx_k_binstate2, sizeof(__pyx_k_binstate2), 0, 0, 1, 1},
+    {&__pyx_n_s_cana_canalization_cboolean_canal, __pyx_k_cana_canalization_cboolean_canal, sizeof(__pyx_k_cana_canalization_cboolean_canal), 0, 0, 1, 1},
+    {&__pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_k_cana_canalization_cboolean_canal_2, sizeof(__pyx_k_cana_canalization_cboolean_canal_2), 0, 0, 1, 0},
+    {&__pyx_n_s_cana_cutils, __pyx_k_cana_cutils, sizeof(__pyx_k_cana_cutils), 0, 0, 1, 1},
+    {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1},
+    {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
+    {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1},
+    {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1},
+    {&__pyx_n_s_density, __pyx_k_density, sizeof(__pyx_k_density), 0, 0, 1, 1},
+    {&__pyx_n_s_density_groups, __pyx_k_density_groups, sizeof(__pyx_k_density_groups), 0, 0, 1, 1},
+    {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0},
+    {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1},
+    {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0},
+    {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
+    {&__pyx_n_s_expand_ts_logic_fast, __pyx_k_expand_ts_logic_fast, sizeof(__pyx_k_expand_ts_logic_fast), 0, 0, 1, 1},
+    {&__pyx_n_s_expand_wildcard_schemata, __pyx_k_expand_wildcard_schemata, sizeof(__pyx_k_expand_wildcard_schemata), 0, 0, 1, 1},
+    {&__pyx_n_s_find_implicants_qm, __pyx_k_find_implicants_qm, sizeof(__pyx_k_find_implicants_qm), 0, 0, 1, 1},
+    {&__pyx_n_s_find_wildcards, __pyx_k_find_wildcards, sizeof(__pyx_k_find_wildcards), 0, 0, 1, 1},
+    {&__pyx_n_s_flip_binstate_bit, __pyx_k_flip_binstate_bit, sizeof(__pyx_k_flip_binstate_bit), 0, 0, 1, 1},
+    {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0},
+    {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1},
+    {&__pyx_n_s_groups, __pyx_k_groups, sizeof(__pyx_k_groups), 0, 0, 1, 1},
+    {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
+    {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1},
+    {&__pyx_n_s_implicant, __pyx_k_implicant, sizeof(__pyx_k_implicant), 0, 0, 1, 1},
+    {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+    {&__pyx_n_s_input_binstates, __pyx_k_input_binstates, sizeof(__pyx_k_input_binstates), 0, 0, 1, 1},
+    {&__pyx_n_s_input_to_wildcards, __pyx_k_input_to_wildcards, sizeof(__pyx_k_input_to_wildcards), 0, 0, 1, 1},
+    {&__pyx_n_s_input_wildcard_coverage, __pyx_k_input_wildcard_coverage, sizeof(__pyx_k_input_wildcard_coverage), 0, 0, 1, 1},
+    {&__pyx_n_s_input_wildcard_coverage_locals_g, __pyx_k_input_wildcard_coverage_locals_g, sizeof(__pyx_k_input_wildcard_coverage_locals_g), 0, 0, 1, 1},
+    {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1},
+    {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0},
+    {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1},
+    {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
+    {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+    {&__pyx_n_s_make_density_groups, __pyx_k_make_density_groups, sizeof(__pyx_k_make_density_groups), 0, 0, 1, 1},
+    {&__pyx_n_s_matched_implicants, __pyx_k_matched_implicants, sizeof(__pyx_k_matched_implicants), 0, 0, 1, 1},
+    {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+    {&__pyx_n_s_newstate, __pyx_k_newstate, sizeof(__pyx_k_newstate), 0, 0, 1, 1},
+    {&__pyx_n_s_nwildcards, __pyx_k_nwildcards, sizeof(__pyx_k_nwildcards), 0, 0, 1, 1},
+    {&__pyx_n_s_permut_indexes, __pyx_k_permut_indexes, sizeof(__pyx_k_permut_indexes), 0, 0, 1, 1},
+    {&__pyx_n_s_pi, __pyx_k_pi, sizeof(__pyx_k_pi), 0, 0, 1, 1},
+    {&__pyx_n_s_pi_coverage, __pyx_k_pi_coverage, sizeof(__pyx_k_pi_coverage), 0, 0, 1, 1},
+    {&__pyx_n_s_pi_covers, __pyx_k_pi_covers, sizeof(__pyx_k_pi_covers), 0, 0, 1, 1},
+    {&__pyx_n_s_pi_covers_fast, __pyx_k_pi_covers_fast, sizeof(__pyx_k_pi_covers_fast), 0, 0, 1, 1},
+    {&__pyx_n_s_piset, __pyx_k_piset, sizeof(__pyx_k_piset), 0, 0, 1, 1},
+    {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1},
+    {&__pyx_n_s_prime_implicants, __pyx_k_prime_implicants, sizeof(__pyx_k_prime_implicants), 0, 0, 1, 1},
+    {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+    {&__pyx_n_s_replace_wildcard, __pyx_k_replace_wildcard, sizeof(__pyx_k_replace_wildcard), 0, 0, 1, 1},
+    {&__pyx_n_s_return_pi_coverage, __pyx_k_return_pi_coverage, sizeof(__pyx_k_return_pi_coverage), 0, 0, 1, 1},
+    {&__pyx_n_s_schemata, __pyx_k_schemata, sizeof(__pyx_k_schemata), 0, 0, 1, 1},
+    {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1},
+    {&__pyx_n_s_statenum_to_binstate, __pyx_k_statenum_to_binstate, sizeof(__pyx_k_statenum_to_binstate), 0, 0, 1, 1},
+    {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+    {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1},
+    {&__pyx_n_s_ts_covers_fast, __pyx_k_ts_covers_fast, sizeof(__pyx_k_ts_covers_fast), 0, 0, 1, 1},
+    {&__pyx_n_s_two_symbol, __pyx_k_two_symbol, sizeof(__pyx_k_two_symbol), 0, 0, 1, 1},
+    {&__pyx_n_s_two_symbols, __pyx_k_two_symbols, sizeof(__pyx_k_two_symbols), 0, 0, 1, 1},
+    {&__pyx_n_s_used, __pyx_k_used, sizeof(__pyx_k_used), 0, 0, 1, 1},
+    {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1},
+    {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1},
+    {&__pyx_n_s_wildstatenum, __pyx_k_wildstatenum, sizeof(__pyx_k_wildstatenum), 0, 0, 1, 1},
+    {&__pyx_n_s_wildstates, __pyx_k_wildstates, sizeof(__pyx_k_wildstates), 0, 0, 1, 1},
+    {&__pyx_n_s_wnum, __pyx_k_wnum, sizeof(__pyx_k_wnum), 0, 0, 1, 1},
+    {&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1},
+    {0, 0, 0, 0, 0, 0, 0}
+  };
+  return __Pyx_InitStrings(__pyx_string_tab);
+}
+/* #### Code section: cached_builtins ### */
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 112, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 165, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 167, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: cached_constants ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "cana/canalization/cboolean_canalization.pyx":165
+ *     n = len(imp_list)
+ *     if len(binstate_str) != n:
+ *         raise ValueError("Implicant and binstate must have the same length")             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(n):
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Implicant_and_binstate_must_have); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "cana/canalization/cboolean_canalization.pyx":26
+ * # Quine-McCluskey Functions
+ * #
+ * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+  __pyx_tuple__5 = PyTuple_Pack(4, __pyx_n_s_input_binstates, __pyx_n_s_density_groups, __pyx_n_s_binstate, __pyx_n_s_density); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+  __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_make_density_groups, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 26, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":40
+ * 
+ * 
+ * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
+ *     """
+ *     Compare two binary states and replace any differing bits by a wildcard.
+ */
+  __pyx_tuple__7 = PyTuple_Pack(4, __pyx_n_s_binstate1, __pyx_n_s_binstate2, __pyx_n_s_b0, __pyx_n_s_b1); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+  __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_find_wildcards, 40, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 40, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":54
+ * 
+ * 
+ * def binary_density(binstate):             # <<<<<<<<<<<<<<
+ *     """
+ *     Find the density (number of 1s) for a term with possible wildcards.
+ */
+  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__9);
+  __Pyx_GIVEREF(__pyx_tuple__9);
+  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_binary_density, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 54, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":61
+ * 
+ * 
+ * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
+ *     """
+ *     Return the binary state with a wildcard at the idx position.
+ */
+  __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_binstate, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_replace_wildcard, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 61, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":68
+ * 
+ * 
+ * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
+ *     """ Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.
+ * 
+ */
+  __pyx_tuple__13 = PyTuple_Pack(13, __pyx_n_s_input_binstates, __pyx_n_s_verbose, __pyx_n_s_matched_implicants, __pyx_n_s_done, __pyx_n_s_density_groups, __pyx_n_s_used, __pyx_n_s_density, __pyx_n_s_binstate0, __pyx_n_s_idx, __pyx_n_s_b0, __pyx_n_s_binstate1, __pyx_n_s_groups, __pyx_n_s_prime_implicants); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+  __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_find_implicants_qm, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __pyx_tuple__15 = PyTuple_Pack(1, ((PyObject *)Py_False)); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "cana/canalization/cboolean_canalization.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint pi_covers_fast(object implicant, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage check for wildcard schemata."""
+ *     cdef list imp_list
+ */
+  __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_implicant, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_pi_covers_fast, 151, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 151, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":252
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):             # <<<<<<<<<<<<<<
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
+  __pyx_tuple__18 = PyTuple_Pack(2, __pyx_n_s_two_symbols, __pyx_n_s_permut_indexes); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+  __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_expand_ts_logic_fast, 252, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 252, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":282
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
+  __pyx_tuple__20 = PyTuple_Pack(3, __pyx_n_s_two_symbol, __pyx_n_s_permut_indexes, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+  __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_ts_covers_fast, 282, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 282, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":310
+ * 
+ * 
+ * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
+ *     """Determine if a binarystate is covered by a specific implicant."""
+ *     return pi_covers_fast(implicant, binstate)
+ */
+  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_pi_covers, 310, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 310, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":315
+ * 
+ * 
+ * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
+ *     """
+ *     Expand a wildcard schemata to list all binary states it covers.
+ */
+  __pyx_tuple__23 = PyTuple_Pack(8, __pyx_n_s_schemata, __pyx_n_s_nwildcards, __pyx_n_s_binary_states, __pyx_n_s_wildstatenum, __pyx_n_s_wildstates, __pyx_n_s_wnum, __pyx_n_s_newstate, __pyx_n_s_b); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 315, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+  __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_expand_wildcard_schemata, 315, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 315, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":347
+ * 
+ * 
+ * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+  __pyx_tuple__25 = PyTuple_Pack(4, __pyx_n_s_prime_implicants, __pyx_n_s_pi_coverage, __pyx_n_s_pi, __pyx_n_s_binstate); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 347, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_return_pi_coverage, 347, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 347, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":367
+ * 
+ * 
+ * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+  __pyx_tuple__27 = PyTuple_Pack(9, __pyx_n_s_pi_coverage, __pyx_n_s_k, __pyx_n_s_input_to_wildcards, __pyx_n_s_binstate, __pyx_n_s_piset, __pyx_n_s_i, __pyx_n_s_i, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cana_canalization_cboolean_canal_2, __pyx_n_s_input_wildcard_coverage, 367, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+/* #### Code section: init_constants ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) {
+  __pyx_umethod_PyList_Type_pop.type = (PyObject*)&PyList_Type;
+  __pyx_umethod_PyList_Type_pop.method_name = &__pyx_n_s_pop;
+  if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_globals ### */
+
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {
+  return 0;
+}
+/* #### Code section: init_module ### */
+
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/
+
+static int __Pyx_modinit_global_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_type_init_code(void) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage_spec, NULL); if (unlikely(!__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage)) __PYX_ERR(0, 367, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage_spec, __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage) < 0) __PYX_ERR(0, 367, __pyx_L1_error)
+  #else
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage) < 0) __PYX_ERR(0, 367, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage->tp_dictoffset && __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct__input_wildcard_coverage->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  #endif
+  #if CYTHON_USE_TYPE_SPECS
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr_spec, NULL); if (unlikely(!__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr)) __PYX_ERR(0, 383, __pyx_L1_error)
+  if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr_spec, __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 383, __pyx_L1_error)
+  #else
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr = &__pyx_type_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  #endif
+  #if !CYTHON_USE_TYPE_SPECS
+  if (__Pyx_PyType_Ready(__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(0, 383, __pyx_L1_error)
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr->tp_print = 0;
+  #endif
+  #if !CYTHON_COMPILING_IN_LIMITED_API
+  if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) {
+    __pyx_ptype_4cana_12canalization_21cboolean_canalization___pyx_scope_struct_1_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+  }
+  #endif
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_type_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+
+#if PY_MAJOR_VERSION >= 3
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_cboolean_canalization(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_cboolean_canalization},
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "cboolean_canalization",
+      __pyx_k_Cythonized_Boolean_Canalization, /* m_doc */
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      0, /* m_size */
+    #elif CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstate), /* m_size */
+    #else
+      -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+#endif
+
+#ifndef CYTHON_NO_PYINIT_EXPORT
+#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#elif PY_MAJOR_VERSION < 3
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" void
+#else
+#define __Pyx_PyMODINIT_FUNC void
+#endif
+#else
+#ifdef __cplusplus
+#define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+#else
+#define __Pyx_PyMODINIT_FUNC PyObject *
+#endif
+#endif
+
+
+#if PY_MAJOR_VERSION < 3
+__Pyx_PyMODINIT_FUNC initcboolean_canalization(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC initcboolean_canalization(void)
+#else
+__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    #if PY_VERSION_HEX >= 0x030700A1
+    static PY_INT64_T main_interpreter_id = -1;
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return (unlikely(current_id == -1)) ? -1 : 0;
+    } else if (unlikely(main_interpreter_id != current_id))
+    #else
+    static PyInterpreterState *main_interpreter = NULL;
+    PyInterpreterState *current_interpreter = PyThreadState_Get()->interp;
+    if (!main_interpreter) {
+        main_interpreter = current_interpreter;
+    } else if (unlikely(main_interpreter != current_interpreter))
+    #endif
+    {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none)
+#else
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+#endif
+{
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+            result = PyModule_AddObject(module, to_name, value);
+#else
+            result = PyDict_SetItemString(moddict, to_name, value);
+#endif
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    moddict = module;
+#else
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+#endif
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_cboolean_canalization(PyObject *__pyx_pyinit_module)
+#endif
+#endif
+{
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module 'cboolean_canalization' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #elif PY_MAJOR_VERSION >= 3
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_m = __pyx_pyinit_module;
+  Py_INCREF(__pyx_m);
+  #else
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("cboolean_canalization", __pyx_methods, __pyx_k_Cythonized_Boolean_Canalization, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #elif CYTHON_USE_MODULE_STATE
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  {
+    int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "cboolean_canalization" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #endif
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if CYTHON_REFNANNY
+__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+if (!__Pyx_RefNanny) {
+  PyErr_Clear();
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+  if (!__Pyx_RefNanny)
+      Py_FatalError("failed to import 'refnanny' module");
+}
+#endif
+  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cboolean_canalization(void)", 0);
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pxy_PyFrame_Initialize_Offsets
+  __Pxy_PyFrame_Initialize_Offsets();
+  #endif
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_AsyncGen_USED
+  if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  PyEval_InitThreads();
+  #endif
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_cana__canalization__cboolean_canalization) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "cana.canalization.cboolean_canalization")) {
+      if (unlikely((PyDict_SetItemString(modules, "cana.canalization.cboolean_canalization", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code();
+  (void)__Pyx_modinit_variable_export_code();
+  (void)__Pyx_modinit_function_export_code();
+  if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_type_import_code();
+  (void)__Pyx_modinit_variable_import_code();
+  (void)__Pyx_modinit_function_import_code();
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+
+  /* "cana/canalization/cboolean_canalization.pyx":17
+ * import cython
+ * 
+ * from cana.cutils import *             # <<<<<<<<<<<<<<
+ * 
+ * WILDCARD_SYMBOL = '#'
+ */
+  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_n_s__3);
+  __Pyx_GIVEREF(__pyx_n_s__3);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s__3)) __PYX_ERR(0, 17, __pyx_L1_error);
+  __pyx_t_3 = __Pyx_Import(__pyx_n_s_cana_cutils, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__pyx_import_star(__pyx_t_3) < 0) __PYX_ERR(0, 17, __pyx_L1_error);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":19
+ * from cana.cutils import *
+ * 
+ * WILDCARD_SYMBOL = '#'             # <<<<<<<<<<<<<<
+ * SYMMETRIC_WILDCARD_SYMBOL = '*'
+ * 
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_WILDCARD_SYMBOL, __pyx_kp_u__4) < 0) __PYX_ERR(0, 19, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":20
+ * 
+ * WILDCARD_SYMBOL = '#'
+ * SYMMETRIC_WILDCARD_SYMBOL = '*'             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SYMMETRIC_WILDCARD_SYMBOL, __pyx_kp_u__3) < 0) __PYX_ERR(0, 20, __pyx_L1_error)
+
+  /* "cana/canalization/cboolean_canalization.pyx":26
+ * # Quine-McCluskey Functions
+ * #
+ * def make_density_groups(input_binstates):             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_1make_density_groups, 0, __pyx_n_s_make_density_groups, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_make_density_groups, __pyx_t_3) < 0) __PYX_ERR(0, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":40
+ * 
+ * 
+ * def find_wildcards(binstate1, binstate2):             # <<<<<<<<<<<<<<
+ *     """
+ *     Compare two binary states and replace any differing bits by a wildcard.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_3find_wildcards, 0, __pyx_n_s_find_wildcards, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_wildcards, __pyx_t_3) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":54
+ * 
+ * 
+ * def binary_density(binstate):             # <<<<<<<<<<<<<<
+ *     """
+ *     Find the density (number of 1s) for a term with possible wildcards.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_5binary_density, 0, __pyx_n_s_binary_density, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_binary_density, __pyx_t_3) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":61
+ * 
+ * 
+ * def replace_wildcard(binstate, idx):             # <<<<<<<<<<<<<<
+ *     """
+ *     Return the binary state with a wildcard at the idx position.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_7replace_wildcard, 0, __pyx_n_s_replace_wildcard, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_replace_wildcard, __pyx_t_3) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":68
+ * 
+ * 
+ * def find_implicants_qm(input_binstates, verbose=False):             # <<<<<<<<<<<<<<
+ *     """ Finds the prime implicants (PI) using the Quine-McCluskey algorithm :cite:`Quine:1955`.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_9find_implicants_qm, 0, __pyx_n_s_find_implicants_qm, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__15);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_implicants_qm, __pyx_t_3) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":151
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint pi_covers_fast(object implicant, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage check for wildcard schemata."""
+ *     cdef list imp_list
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_11pi_covers_fast, 0, __pyx_n_s_pi_covers_fast, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pi_covers_fast, __pyx_t_3) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":252
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):             # <<<<<<<<<<<<<<
+ *     """Generate all permutations for two-symbol schemata groups."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_13expand_ts_logic_fast, 0, __pyx_n_s_expand_ts_logic_fast, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_expand_ts_logic_fast, __pyx_t_3) < 0) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":282
+ * @cython.boundscheck(False)
+ * @cython.wraparound(False)
+ * cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):             # <<<<<<<<<<<<<<
+ *     """Fast coverage test for two-symbol schemata with permutations."""
+ *     cdef list idx_groups = _normalize_index_groups(permut_indexes)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_15ts_covers_fast, 0, __pyx_n_s_ts_covers_fast, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ts_covers_fast, __pyx_t_3) < 0) __PYX_ERR(0, 282, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":310
+ * 
+ * 
+ * def __pi_covers(implicant, binstate):             # <<<<<<<<<<<<<<
+ *     """Determine if a binarystate is covered by a specific implicant."""
+ *     return pi_covers_fast(implicant, binstate)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_17__pi_covers, 0, __pyx_n_s_pi_covers, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pi_covers, __pyx_t_3) < 0) __PYX_ERR(0, 310, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":315
+ * 
+ * 
+ * def expand_wildcard_schemata(schemata):             # <<<<<<<<<<<<<<
+ *     """
+ *     Expand a wildcard schemata to list all binary states it covers.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_19expand_wildcard_schemata, 0, __pyx_n_s_expand_wildcard_schemata, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 315, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_expand_wildcard_schemata, __pyx_t_3) < 0) __PYX_ERR(0, 315, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":347
+ * 
+ * 
+ * def return_pi_coverage(prime_implicants):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_21return_pi_coverage, 0, __pyx_n_s_return_pi_coverage, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 347, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_return_pi_coverage, __pyx_t_3) < 0) __PYX_ERR(0, 347, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":367
+ * 
+ * 
+ * def input_wildcard_coverage(pi_coverage):             # <<<<<<<<<<<<<<
+ *     """Computes the binary states coverage by Prime Implicant schematas.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_12canalization_21cboolean_canalization_23input_wildcard_coverage, 0, __pyx_n_s_input_wildcard_coverage, NULL, __pyx_n_s_cana_canalization_cboolean_canal, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_input_wildcard_coverage, __pyx_t_3) < 0) __PYX_ERR(0, 367, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/canalization/cboolean_canalization.pyx":1
+ * # -*- coding: utf-8 -*-             # <<<<<<<<<<<<<<
+ * """
+ * (Cythonized) Boolean Canalization
+ */
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  if (__pyx_m) {
+    if (__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init cana.canalization.cboolean_canalization", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init cana.canalization.cboolean_canalization");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #elif PY_MAJOR_VERSION >= 3
+  return __pyx_m;
+  #else
+  return;
+  #endif
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+#if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
+    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    return __Pyx_GetBuiltinName(name);
+}
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* DictGetItem */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            if (unlikely(PyTuple_Check(key))) {
+                PyObject* args = PyTuple_Pack(1, key);
+                if (likely(args)) {
+                    PyErr_SetObject(PyExc_KeyError, args);
+                    Py_DECREF(args);
+                }
+            } else {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* IterFinish */
+static CYTHON_INLINE int __Pyx_IterFinish(void) {
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
+    if (unlikely(exc_type)) {
+        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
+            return -1;
+        __Pyx_PyErr_Clear();
+        return 0;
+    }
+    return 0;
+}
+
+/* UnpackItemEndCheck */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    }
+    return __Pyx_IterFinish();
+}
+
+/* SliceObject */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
+        Py_ssize_t cstart, Py_ssize_t cstop,
+        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
+        int has_cstart, int has_cstop, int wraparound) {
+    __Pyx_TypeName obj_type_name;
+#if CYTHON_USE_TYPE_SLOTS
+    PyMappingMethods* mp;
+#if PY_MAJOR_VERSION < 3
+    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
+    if (likely(ms && ms->sq_slice)) {
+        if (!has_cstart) {
+            if (_py_start && (*_py_start != Py_None)) {
+                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
+                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstart = 0;
+        }
+        if (!has_cstop) {
+            if (_py_stop && (*_py_stop != Py_None)) {
+                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
+                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstop = PY_SSIZE_T_MAX;
+        }
+        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
+            Py_ssize_t l = ms->sq_length(obj);
+            if (likely(l >= 0)) {
+                if (cstop < 0) {
+                    cstop += l;
+                    if (cstop < 0) cstop = 0;
+                }
+                if (cstart < 0) {
+                    cstart += l;
+                    if (cstart < 0) cstart = 0;
+                }
+            } else {
+                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                    goto bad;
+                PyErr_Clear();
+            }
+        }
+        return ms->sq_slice(obj, cstart, cstop);
+    }
+#else
+    CYTHON_UNUSED_VAR(wraparound);
+#endif
+    mp = Py_TYPE(obj)->tp_as_mapping;
+    if (likely(mp && mp->mp_subscript))
+#else
+    CYTHON_UNUSED_VAR(wraparound);
+#endif
+    {
+        PyObject* result;
+        PyObject *py_slice, *py_start, *py_stop;
+        if (_py_slice) {
+            py_slice = *_py_slice;
+        } else {
+            PyObject* owned_start = NULL;
+            PyObject* owned_stop = NULL;
+            if (_py_start) {
+                py_start = *_py_start;
+            } else {
+                if (has_cstart) {
+                    owned_start = py_start = PyInt_FromSsize_t(cstart);
+                    if (unlikely(!py_start)) goto bad;
+                } else
+                    py_start = Py_None;
+            }
+            if (_py_stop) {
+                py_stop = *_py_stop;
+            } else {
+                if (has_cstop) {
+                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
+                    if (unlikely(!py_stop)) {
+                        Py_XDECREF(owned_start);
+                        goto bad;
+                    }
+                } else
+                    py_stop = Py_None;
+            }
+            py_slice = PySlice_New(py_start, py_stop, Py_None);
+            Py_XDECREF(owned_start);
+            Py_XDECREF(owned_stop);
+            if (unlikely(!py_slice)) goto bad;
+        }
+#if CYTHON_USE_TYPE_SLOTS
+        result = mp->mp_subscript(obj, py_slice);
+#else
+        result = PyObject_GetItem(obj, py_slice);
+#endif
+        if (!_py_slice) {
+            Py_DECREF(py_slice);
+        }
+        return result;
+    }
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+bad:
+    return NULL;
+}
+
+/* PyIntBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_MAYBE_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+        
+            x = (long)((unsigned long)a + (unsigned long)b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        if (unlikely(__Pyx_PyLong_IsZero(op1))) {
+            return __Pyx_NewRef(op2);
+        }
+        if (likely(__Pyx_PyLong_IsCompact(op1))) {
+            a = __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+            double result;
+            
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* GetItemInt */
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (unlikely(!j)) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyList_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyTuple_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_subscript) {
+            PyObject *r, *key = PyInt_FromSsize_t(i);
+            if (unlikely(!key)) return NULL;
+            r = mm->mp_subscript(o, key);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return sm->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || !PyMapping_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* ObjectGetItem */
+#if CYTHON_USE_TYPE_SLOTS
+static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) {
+    PyObject *runerr = NULL;
+    Py_ssize_t key_value;
+    key_value = __Pyx_PyIndex_AsSsize_t(index);
+    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
+        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
+    }
+    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+        __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index));
+        PyErr_Clear();
+        PyErr_Format(PyExc_IndexError,
+            "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name);
+        __Pyx_DECREF_TypeName(index_type_name);
+    }
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) {
+    __Pyx_TypeName obj_type_name;
+    if (likely(PyType_Check(obj))) {
+        PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem);
+        if (!meth) {
+            PyErr_Clear();
+        } else {
+            PyObject *result = __Pyx_PyObject_CallOneArg(meth, key);
+            Py_DECREF(meth);
+            return result;
+        }
+    }
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) {
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyMappingMethods *mm = tp->tp_as_mapping;
+    PySequenceMethods *sm = tp->tp_as_sequence;
+    if (likely(mm && mm->mp_subscript)) {
+        return mm->mp_subscript(obj, key);
+    }
+    if (likely(sm && sm->sq_item)) {
+        return __Pyx_PyObject_GetIndex(obj, key);
+    }
+    return __Pyx_PyObject_GetItem_Slow(obj, key);
+}
+#endif
+
+/* RaiseUnboundLocalError */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
+    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
+}
+
+/* PyIntCompare */
+static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_UNUSED_VAR(inplace);
+    if (op1 == op2) {
+        return 1;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        return (a == b);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = __Pyx_PyLong_DigitCount(op1);
+        const digit* digits = __Pyx_PyLong_Digits(op1);
+        if (intval == 0) {
+            return (__Pyx_PyLong_IsZero(op1) == 1);
+        } else if (intval < 0) {
+            if (__Pyx_PyLong_IsNonNeg(op1))
+                return 0;
+            intval = -intval;
+        } else {
+            if (__Pyx_PyLong_IsNeg(op1))
+                return 0;
+        }
+        uintval = (unsigned long) intval;
+#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 4)) {
+            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 3)) {
+            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 2)) {
+            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 1)) {
+            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+        return (unequal == 0);
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+        return ((double)a == (double)b);
+    }
+    return __Pyx_PyObject_IsTrueAndDecref(
+        PyObject_RichCompare(op1, op2, Py_EQ));
+}
+
+/* RaiseException */
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
 
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  if (__pyx_m) {
-    if (__pyx_d) {
-      __Pyx_AddTraceback("init cana.canalization.cboolean_canalization", __pyx_clineno, __pyx_lineno, __pyx_filename);
+/* GetItemIntUnicode */
+static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i,
+                                                           int wraparound, int boundscheck) {
+    Py_ssize_t length;
+    if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return (Py_UCS4)-1;
+    if (wraparound | boundscheck) {
+        length = __Pyx_PyUnicode_GET_LENGTH(ustring);
+        if (wraparound & unlikely(i < 0)) i += length;
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(i, length))) {
+            return __Pyx_PyUnicode_READ_CHAR(ustring, i);
+        } else {
+            PyErr_SetString(PyExc_IndexError, "string index out of range");
+            return (Py_UCS4)-1;
+        }
+    } else {
+        return __Pyx_PyUnicode_READ_CHAR(ustring, i);
     }
-    Py_CLEAR(__pyx_m);
-  } else if (!PyErr_Occurred()) {
-    PyErr_SetString(PyExc_ImportError, "init cana.canalization.cboolean_canalization");
-  }
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  #if CYTHON_PEP489_MULTI_PHASE_INIT
-  return (__pyx_m != NULL) ? 0 : -1;
-  #elif PY_MAJOR_VERSION >= 3
-  return __pyx_m;
-  #else
-  return;
-  #endif
 }
 
-/* --- Runtime support code --- */
-/* Refnanny */
-#if CYTHON_REFNANNY
-static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
-    PyObject *m = NULL, *p = NULL;
-    void *r = NULL;
-    m = PyImport_ImportModule(modname);
-    if (!m) goto end;
-    p = PyObject_GetAttrString(m, "RefNannyAPI");
-    if (!p) goto end;
-    r = PyLong_AsVoidPtr(p);
-end:
-    Py_XDECREF(p);
-    Py_XDECREF(m);
-    return (__Pyx_RefNannyAPIStruct *)r;
+/* SliceTupleAndList */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) {
+    Py_ssize_t start = *_start, stop = *_stop, length = *_length;
+    if (start < 0) {
+        start += length;
+        if (start < 0)
+            start = 0;
+    }
+    if (stop < 0)
+        stop += length;
+    else if (stop > length)
+        stop = length;
+    *_length = stop - start;
+    *_start = start;
+    *_stop = stop;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(
+            PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
+    Py_ssize_t length = PyList_GET_SIZE(src);
+    __Pyx_crop_slice(&start, &stop, &length);
+    if (length <= 0) {
+        return PyList_New(0);
+    }
+    return __Pyx_PyList_FromArray(((PyListObject*)src)->ob_item + start, length);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(
+            PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
+    Py_ssize_t length = PyTuple_GET_SIZE(src);
+    __Pyx_crop_slice(&start, &stop, &length);
+    return __Pyx_PyTuple_FromArray(((PyTupleObject*)src)->ob_item + start, length);
 }
 #endif
 
-/* PyObjectGetAttrStr */
+/* pyfrozenset_new */
+static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) {
+    if (it) {
+        PyObject* result;
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject* args;
+        args = PyTuple_Pack(1, it);
+        if (unlikely(!args))
+            return NULL;
+        result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL);
+        Py_DECREF(args);
+        return result;
+#else
+        if (PyFrozenSet_CheckExact(it)) {
+            Py_INCREF(it);
+            return it;
+        }
+        result = PyFrozenSet_New(it);
+        if (unlikely(!result))
+            return NULL;
+        if ((PY_VERSION_HEX >= 0x031000A1) || likely(PySet_GET_SIZE(result)))
+            return result;
+        Py_DECREF(result);
+#endif
+    }
 #if CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
-    PyTypeObject* tp = Py_TYPE(obj);
-    if (likely(tp->tp_getattro))
-        return tp->tp_getattro(obj, attr_name);
-#if PY_MAJOR_VERSION < 3
-    if (likely(tp->tp_getattr))
-        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+    return PyFrozenSet_Type.tp_new(&PyFrozenSet_Type, __pyx_empty_tuple, NULL);
+#else
+    return PyObject_Call((PyObject*)&PyFrozenSet_Type, __pyx_empty_tuple, NULL);
 #endif
-    return PyObject_GetAttr(obj, attr_name);
 }
-#endif
 
-/* GetBuiltinName */
-static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
-    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
-    if (unlikely(!result)) {
-        PyErr_Format(PyExc_NameError,
-#if PY_MAJOR_VERSION >= 3
-            "name '%U' is not defined", name);
-#else
-            "name '%.200s' is not defined", PyString_AS_STRING(name));
-#endif
+/* PySetContains */
+static int __Pyx_PySet_ContainsUnhashable(PyObject *set, PyObject *key) {
+    int result = -1;
+    if (PySet_Check(key) && PyErr_ExceptionMatches(PyExc_TypeError)) {
+        PyObject *tmpkey;
+        PyErr_Clear();
+        tmpkey = __Pyx_PyFrozenSet_New(key);
+        if (tmpkey != NULL) {
+            result = PySet_Contains(set, tmpkey);
+            Py_DECREF(tmpkey);
+        }
     }
     return result;
 }
+static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq) {
+    int result = PySet_Contains(set, key);
+    if (unlikely(result < 0)) {
+        result = __Pyx_PySet_ContainsUnhashable(set, key);
+    }
+    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
+}
 
-/* PyDictVersioning */
-#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
-    PyObject *dict = Py_TYPE(obj)->tp_dict;
-    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+/* SetItemInt */
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+    int r;
+    if (unlikely(!j)) return -1;
+    r = PyObject_SetItem(o, j, v);
+    Py_DECREF(j);
+    return r;
 }
-static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
-    PyObject **dictptr = NULL;
-    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
-    if (offset) {
-#if CYTHON_COMPILING_IN_CPYTHON
-        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
+                                               CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
+            PyObject* old = PyList_GET_ITEM(o, n);
+            Py_INCREF(v);
+            PyList_SET_ITEM(o, n, v);
+            Py_DECREF(old);
+            return 1;
+        }
+    } else {
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_ass_subscript) {
+            int r;
+            PyObject *key = PyInt_FromSsize_t(i);
+            if (unlikely(!key)) return -1;
+            r = mm->mp_ass_subscript(o, key, v);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_ass_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return -1;
+                    PyErr_Clear();
+                }
+            }
+            return sm->sq_ass_item(o, i, v);
+        }
+    }
 #else
-        dictptr = _PyObject_GetDictPtr(obj);
-#endif
+    if (is_list || !PyMapping_Check(o))
+    {
+        return PySequence_SetItem(o, i, v);
     }
-    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+#endif
+    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
 }
-static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
-    PyObject *dict = Py_TYPE(obj)->tp_dict;
-    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
-        return 0;
-    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
-#endif
 
-/* GetModuleGlobalName */
-#if CYTHON_USE_DICT_VERSIONS
-static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
 #else
-static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
 #endif
-{
-    PyObject *result;
-#if !CYTHON_AVOID_BORROWED_REFS
-#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1
-    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    } else if (unlikely(PyErr_Occurred())) {
-        return NULL;
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
     }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* UnpackUnboundCMethod */
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) {
+    PyObject *result;
+    PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
+    if (unlikely(!selfless_args)) return NULL;
+    result = PyObject_Call(method, selfless_args, kwargs);
+    Py_DECREF(selfless_args);
+    return result;
+}
+static PyMethodDef __Pyx_UnboundCMethod_Def = {
+     "CythonUnboundCMethod",
+     __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall),
+     METH_VARARGS | METH_KEYWORDS,
+     NULL
+};
+static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
+    PyObject *method;
+    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
+    if (unlikely(!method))
+        return -1;
+    target->method = method;
+#if CYTHON_COMPILING_IN_CPYTHON
+    #if PY_MAJOR_VERSION >= 3
+    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
+    #else
+    if (likely(!__Pyx_CyOrPyCFunction_Check(method)))
+    #endif
+    {
+        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
+        target->func = descr->d_method->ml_meth;
+        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    } else
+#endif
+#if CYTHON_COMPILING_IN_PYPY
 #else
-    result = PyDict_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    }
+    if (PyCFunction_Check(method))
 #endif
+    {
+        PyObject *self;
+        int self_found;
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        self = PyObject_GetAttrString(method, "__self__");
+        if (!self) {
+            PyErr_Clear();
+        }
 #else
-    result = PyObject_GetItem(__pyx_d, name);
-    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
-    if (likely(result)) {
-        return __Pyx_NewRef(result);
-    }
-    PyErr_Clear();
+        self = PyCFunction_GET_SELF(method);
 #endif
-    return __Pyx_GetBuiltinName(name);
-}
-
-/* PyCFunctionFastCall */
-#if CYTHON_FAST_PYCCALL
-static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
-    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
-    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-    PyObject *self = PyCFunction_GET_SELF(func);
-    int flags = PyCFunction_GET_FLAGS(func);
-    assert(PyCFunction_Check(func));
-    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)));
-    assert(nargs >= 0);
-    assert(nargs == 0 || args != NULL);
-    /* _PyCFunction_FastCallDict() must not be called with an exception set,
-       because it may clear it (directly or indirectly) and so the
-       caller loses its exception */
-    assert(!PyErr_Occurred());
-    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
-        return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL);
-    } else {
-        return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs);
+        self_found = (self && self != Py_None);
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        Py_XDECREF(self);
+#endif
+        if (self_found) {
+            PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method);
+            if (unlikely(!unbound_method)) return -1;
+            Py_DECREF(method);
+            target->method = unbound_method;
+        }
     }
+    return 0;
 }
+
+/* CallUnboundCMethod0 */
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+    PyObject *args, *result = NULL;
+    if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+#if CYTHON_ASSUME_SAFE_MACROS
+    args = PyTuple_New(1);
+    if (unlikely(!args)) goto bad;
+    Py_INCREF(self);
+    PyTuple_SET_ITEM(args, 0, self);
+#else
+    args = PyTuple_Pack(1, self);
+    if (unlikely(!args)) goto bad;
 #endif
+    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    Py_DECREF(args);
+bad:
+    return result;
+}
 
-/* PyFunctionFastCall */
-#if CYTHON_FAST_PYCALL
-static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
-                                               PyObject *globals) {
-    PyFrameObject *f;
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject **fastlocals;
-    Py_ssize_t i;
-    PyObject *result;
-    assert(globals != NULL);
-    /* XXX Perhaps we should create a specialized
-       PyFrame_New() that doesn't take locals, but does
-       take builtins without sanity checking them.
-       */
-    assert(tstate != NULL);
-    f = PyFrame_New(tstate, co, globals, NULL);
-    if (f == NULL) {
-        return NULL;
+/* pop */
+static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L) {
+    if (__Pyx_IS_TYPE(L, &PySet_Type)) {
+        return PySet_Pop(L);
     }
-    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
-    for (i = 0; i < na; i++) {
-        Py_INCREF(*args);
-        fastlocals[i] = *args++;
+    return __Pyx_PyObject_CallMethod0(L, __pyx_n_s_pop);
+}
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L) {
+    if (likely(PyList_GET_SIZE(L) > (((PyListObject*)L)->allocated >> 1))) {
+        __Pyx_SET_SIZE(L, Py_SIZE(L) - 1);
+        return PyList_GET_ITEM(L, PyList_GET_SIZE(L));
     }
-    result = PyEval_EvalFrameEx(f,0);
-    ++tstate->recursion_depth;
-    Py_DECREF(f);
-    --tstate->recursion_depth;
-    return result;
+    return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyList_Type_pop, L);
 }
-#if 1 || PY_VERSION_HEX < 0x030600B1
-static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
-    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
-    PyObject *globals = PyFunction_GET_GLOBALS(func);
-    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
-    PyObject *closure;
-#if PY_MAJOR_VERSION >= 3
-    PyObject *kwdefs;
 #endif
-    PyObject *kwtuple, **k;
-    PyObject **d;
-    Py_ssize_t nd;
-    Py_ssize_t nk;
-    PyObject *result;
-    assert(kwargs == NULL || PyDict_Check(kwargs));
-    nk = kwargs ? PyDict_Size(kwargs) : 0;
-    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
-        return NULL;
-    }
-    if (
-#if PY_MAJOR_VERSION >= 3
-            co->co_kwonlyargcount == 0 &&
+
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* PyNumberPow2 */
+static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) {
+#if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t shiftby;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(exp))) {
+        shiftby = PyInt_AS_LONG(exp);
+    } else
 #endif
-            likely(kwargs == NULL || nk == 0) &&
-            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
-        if (argdefs == NULL && co->co_argcount == nargs) {
-            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
-            goto done;
-        }
-        else if (nargs == 0 && argdefs != NULL
-                 && co->co_argcount == Py_SIZE(argdefs)) {
-            /* function called with no arguments, but all parameters have
-               a default value: use default values as arguments .*/
-            args = &PyTuple_GET_ITEM(argdefs, 0);
-            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
-            goto done;
-        }
-    }
-    if (kwargs != NULL) {
-        Py_ssize_t pos, i;
-        kwtuple = PyTuple_New(2 * nk);
-        if (kwtuple == NULL) {
-            result = NULL;
-            goto done;
-        }
-        k = &PyTuple_GET_ITEM(kwtuple, 0);
-        pos = i = 0;
-        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
-            Py_INCREF(k[i]);
-            Py_INCREF(k[i+1]);
-            i += 2;
+    if (likely(PyLong_CheckExact(exp))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(exp)) {
+            return PyInt_FromLong(1L);
+        } else if (__Pyx_PyLong_IsNeg(exp)) {
+            goto fallback;
+        } else if (__Pyx_PyLong_IsCompact(exp)) {
+            shiftby = __Pyx_PyLong_CompactValueUnsigned(exp);
+        } else {
+            shiftby = PyLong_AsSsize_t(exp);
         }
-        nk = i / 2;
-    }
-    else {
-        kwtuple = NULL;
-        k = NULL;
+        #else
+        shiftby = PyLong_AsSsize_t(exp);
+        #endif
+    } else {
+        goto fallback;
     }
-    closure = PyFunction_GET_CLOSURE(func);
-#if PY_MAJOR_VERSION >= 3
-    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+    if (likely(shiftby >= 0)) {
+        if ((size_t)shiftby <= sizeof(long) * 8 - 2) {
+            long value = 1L << shiftby;
+            return PyInt_FromLong(value);
+#ifdef HAVE_LONG_LONG
+        } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) {
+            unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby;
+            return PyLong_FromUnsignedLongLong(value);
 #endif
-    if (argdefs != NULL) {
-        d = &PyTuple_GET_ITEM(argdefs, 0);
-        nd = Py_SIZE(argdefs);
-    }
-    else {
-        d = NULL;
-        nd = 0;
+        } else {
+            PyObject *result, *one = PyInt_FromLong(1L);
+            if (unlikely(!one)) return NULL;
+            result = PyNumber_Lshift(one, exp);
+            Py_DECREF(one);
+            return result;
+        }
+    } else if (shiftby == -1 && PyErr_Occurred()) {
+        PyErr_Clear();
     }
-#if PY_MAJOR_VERSION >= 3
-    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
-                               args, (int)nargs,
-                               k, (int)nk,
-                               d, (int)nd, kwdefs, closure);
-#else
-    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
-                               args, (int)nargs,
-                               k, (int)nk,
-                               d, (int)nd, closure);
+fallback:
 #endif
-    Py_XDECREF(kwtuple);
-done:
-    Py_LeaveRecursiveCall();
-    return result;
+    return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none);
 }
-#endif
-#endif
 
-/* PyObjectCall */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
-    PyObject *result;
-    ternaryfunc call = Py_TYPE(func)->tp_call;
-    if (unlikely(!call))
-        return PyObject_Call(func, arg, kw);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = (*call)(func, arg, kw);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
+/* GetException */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
     }
-    return result;
-}
+  #else
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+  #endif
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
-
-/* PyObjectCall2Args */
-static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
-    PyObject *args, *result = NULL;
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyFunction_FastCall(function, args, 2);
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
     }
     #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(function)) {
-        PyObject *args[2] = {arg1, arg2};
-        return __Pyx_PyCFunction_FastCall(function, args, 2);
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
     }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
     #endif
-    args = PyTuple_New(2);
-    if (unlikely(!args)) goto done;
-    Py_INCREF(arg1);
-    PyTuple_SET_ITEM(args, 0, arg1);
-    Py_INCREF(arg2);
-    PyTuple_SET_ITEM(args, 1, arg2);
-    Py_INCREF(function);
-    result = __Pyx_PyObject_Call(function, args, NULL);
-    Py_DECREF(args);
-    Py_DECREF(function);
-done:
-    return result;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
 }
 
-/* PyObjectCallMethO */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
-    PyObject *self, *result;
-    PyCFunction cfunc;
-    cfunc = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
-    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
-        return NULL;
-    result = cfunc(self, arg);
-    Py_LeaveRecursiveCall();
-    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
-        PyErr_SetString(
-            PyExc_SystemError,
-            "NULL result without error in PyObject_Call");
+/* pep479 */
+static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) {
+    PyObject *exc, *val, *tb, *cur_exc;
+    __Pyx_PyThreadState_declare
+    #ifdef __Pyx_StopAsyncIteration_USED
+    int is_async_stopiteration = 0;
+    #endif
+    CYTHON_MAYBE_UNUSED_VAR(in_async_gen);
+    cur_exc = PyErr_Occurred();
+    if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) {
+        #ifdef __Pyx_StopAsyncIteration_USED
+        if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, __Pyx_PyExc_StopAsyncIteration))) {
+            is_async_stopiteration = 1;
+        } else
+        #endif
+            return;
     }
-    return result;
+    __Pyx_PyThreadState_assign
+    __Pyx_GetException(&exc, &val, &tb);
+    Py_XDECREF(exc);
+    Py_XDECREF(val);
+    Py_XDECREF(tb);
+    PyErr_SetString(PyExc_RuntimeError,
+        #ifdef __Pyx_StopAsyncIteration_USED
+        is_async_stopiteration ? "async generator raised StopAsyncIteration" :
+        in_async_gen ? "async generator raised StopIteration" :
+        #endif
+        "generator raised StopIteration");
 }
-#endif
 
-/* PyObjectCallOneArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_New(1);
-    if (unlikely(!args)) return NULL;
-    Py_INCREF(arg);
-    PyTuple_SET_ITEM(args, 0, arg);
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
-}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+/* IterNext */
+static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) {
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
+    if (unlikely(exc_type)) {
+        if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
+            return NULL;
+        __Pyx_PyErr_Clear();
+        Py_INCREF(defval);
+        return defval;
     }
-#endif
-    if (likely(PyCFunction_Check(func))) {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
-            return __Pyx_PyObject_CallMethO(func, arg);
-#if CYTHON_FAST_PYCCALL
-        } else if (__Pyx_PyFastCFunction_Check(func)) {
-            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
-#endif
-        }
+    if (defval) {
+        Py_INCREF(defval);
+        return defval;
     }
-    return __Pyx__PyObject_CallOneArg(func, arg);
+    __Pyx_PyErr_SetNone(PyExc_StopIteration);
+    return NULL;
 }
-#else
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
-    PyObject *result;
-    PyObject *args = PyTuple_Pack(1, arg);
-    if (unlikely(!args)) return NULL;
-    result = __Pyx_PyObject_Call(func, args, NULL);
-    Py_DECREF(args);
-    return result;
+static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) {
+    __Pyx_TypeName iterator_type_name = __Pyx_PyType_GetName(Py_TYPE(iterator));
+    PyErr_Format(PyExc_TypeError,
+        __Pyx_FMT_TYPENAME " object is not an iterator", iterator_type_name);
+    __Pyx_DECREF_TypeName(iterator_type_name);
 }
+static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
+    PyObject* next;
+    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+    if (likely(iternext)) {
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+        next = iternext(iterator);
+        if (likely(next))
+            return next;
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+        if (unlikely(iternext == &_PyObject_NextNotImplemented))
+            return NULL;
 #endif
-
-/* DictGetItem */
-#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
-static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
-    PyObject *value;
-    value = PyDict_GetItemWithError(d, key);
-    if (unlikely(!value)) {
-        if (!PyErr_Occurred()) {
-            if (unlikely(PyTuple_Check(key))) {
-                PyObject* args = PyTuple_Pack(1, key);
-                if (likely(args)) {
-                    PyErr_SetObject(PyExc_KeyError, args);
-                    Py_DECREF(args);
-                }
-            } else {
-                PyErr_SetObject(PyExc_KeyError, key);
-            }
-        }
+#else
+        next = PyIter_Next(iterator);
+        if (likely(next))
+            return next;
+#endif
+    } else if (CYTHON_USE_TYPE_SLOTS || unlikely(!PyIter_Check(iterator))) {
+        __Pyx_PyIter_Next_ErrorNoIterator(iterator);
         return NULL;
     }
-    Py_INCREF(value);
-    return value;
-}
+#if !CYTHON_USE_TYPE_SLOTS
+    else {
+        next = PyIter_Next(iterator);
+        if (likely(next))
+            return next;
+    }
 #endif
+    return __Pyx_PyIter_Next2Default(defval);
+}
 
-/* RaiseArgTupleInvalid */
-static void __Pyx_RaiseArgtupleInvalid(
-    const char* func_name,
-    int exact,
-    Py_ssize_t num_min,
-    Py_ssize_t num_max,
-    Py_ssize_t num_found)
-{
-    Py_ssize_t num_expected;
-    const char *more_or_less;
-    if (num_found < num_min) {
-        num_expected = num_min;
-        more_or_less = "at least";
-    } else {
-        num_expected = num_max;
-        more_or_less = "at most";
-    }
-    if (exact) {
-        more_or_less = "exactly";
-    }
-    PyErr_Format(PyExc_TypeError,
-                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
-                 func_name, more_or_less, num_expected,
-                 (num_expected == 1) ? "" : "s", num_found);
+/* RaiseNoneIterError */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
 }
 
-/* RaiseDoubleKeywords */
-static void __Pyx_RaiseDoubleKeywordsError(
-    const char* func_name,
-    PyObject* kw_name)
-{
-    PyErr_Format(PyExc_TypeError,
-        #if PY_MAJOR_VERSION >= 3
-        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
-        #else
-        "%s() got multiple values for keyword argument '%s'", func_name,
-        PyString_AsString(kw_name));
-        #endif
+/* UnpackTupleError */
+static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
+    if (t == Py_None) {
+      __Pyx_RaiseNoneNotIterableError();
+    } else if (PyTuple_GET_SIZE(t) < index) {
+      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
+    } else {
+      __Pyx_RaiseTooManyValuesError(index);
+    }
 }
 
-/* ParseKeywords */
-static int __Pyx_ParseOptionalKeywords(
-    PyObject *kwds,
-    PyObject **argnames[],
-    PyObject *kwds2,
-    PyObject *values[],
-    Py_ssize_t num_pos_args,
-    const char* function_name)
-{
-    PyObject *key = 0, *value = 0;
-    Py_ssize_t pos = 0;
-    PyObject*** name;
-    PyObject*** first_kw_arg = argnames + num_pos_args;
-    while (PyDict_Next(kwds, &pos, &key, &value)) {
-        name = first_kw_arg;
-        while (*name && (**name != key)) name++;
-        if (*name) {
-            values[name-argnames] = value;
-            continue;
-        }
-        name = first_kw_arg;
-        #if PY_MAJOR_VERSION < 3
-        if (likely(PyString_Check(key))) {
-            while (*name) {
-                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
-                        && _PyString_Eq(**name, key)) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    if ((**argname == key) || (
-                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
-                             && _PyString_Eq(**argname, key))) {
-                        goto arg_passed_twice;
-                    }
-                    argname++;
-                }
-            }
-        } else
-        #endif
-        if (likely(PyUnicode_Check(key))) {
-            while (*name) {
-                int cmp = (**name == key) ? 0 :
-                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                #endif
-                    PyUnicode_Compare(**name, key);
-                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                if (cmp == 0) {
-                    values[name-argnames] = value;
-                    break;
-                }
-                name++;
-            }
-            if (*name) continue;
-            else {
-                PyObject*** argname = argnames;
-                while (argname != first_kw_arg) {
-                    int cmp = (**argname == key) ? 0 :
-                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
-                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
-                    #endif
-                        PyUnicode_Compare(**argname, key);
-                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
-                    if (cmp == 0) goto arg_passed_twice;
-                    argname++;
-                }
-            }
-        } else
-            goto invalid_keyword_type;
-        if (kwds2) {
-            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
-        } else {
-            goto invalid_keyword;
-        }
+/* UnpackTuple2 */
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
+    PyObject *value1 = NULL, *value2 = NULL;
+#if CYTHON_COMPILING_IN_PYPY
+    value1 = PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
+    value2 = PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
+#else
+    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
+    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
+#endif
+    if (decref_tuple) {
+        Py_DECREF(tuple);
     }
+    *pvalue1 = value1;
+    *pvalue2 = value2;
     return 0;
-arg_passed_twice:
-    __Pyx_RaiseDoubleKeywordsError(function_name, key);
-    goto bad;
-invalid_keyword_type:
-    PyErr_Format(PyExc_TypeError,
-        "%.200s() keywords must be strings", function_name);
-    goto bad;
-invalid_keyword:
-    PyErr_Format(PyExc_TypeError,
-    #if PY_MAJOR_VERSION < 3
-        "%.200s() got an unexpected keyword argument '%.200s'",
-        function_name, PyString_AsString(key));
-    #else
-        "%s() got an unexpected keyword argument '%U'",
-        function_name, key);
-    #endif
+#if CYTHON_COMPILING_IN_PYPY
 bad:
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
     return -1;
-}
-
-/* StringJoin */
-#if !CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) {
-    return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL);
-}
 #endif
-
-/* RaiseTooManyValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
-    PyErr_Format(PyExc_ValueError,
-                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
 }
-
-/* RaiseNeedMoreValuesToUnpack */
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
-    PyErr_Format(PyExc_ValueError,
-                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
-                 index, (index == 1) ? "" : "s");
+static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
+                                       int has_known_size, int decref_tuple) {
+    Py_ssize_t index;
+    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
+    iternextfunc iternext;
+    iter = PyObject_GetIter(tuple);
+    if (unlikely(!iter)) goto bad;
+    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
+    iternext = __Pyx_PyObject_GetIterNextFunc(iter);
+    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
+    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
+    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
+    Py_DECREF(iter);
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+unpacking_failed:
+    if (!has_known_size && __Pyx_IterFinish() == 0)
+        __Pyx_RaiseNeedMoreValuesError(index);
+bad:
+    Py_XDECREF(iter);
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
 }
 
-/* IterFinish */
-static CYTHON_INLINE int __Pyx_IterFinish(void) {
-#if CYTHON_FAST_THREAD_STATE
-    PyThreadState *tstate = __Pyx_PyThreadState_Current;
-    PyObject* exc_type = tstate->curexc_type;
-    if (unlikely(exc_type)) {
-        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
-            PyObject *exc_value, *exc_tb;
-            exc_value = tstate->curexc_value;
-            exc_tb = tstate->curexc_traceback;
-            tstate->curexc_type = 0;
-            tstate->curexc_value = 0;
-            tstate->curexc_traceback = 0;
-            Py_DECREF(exc_type);
-            Py_XDECREF(exc_value);
-            Py_XDECREF(exc_tb);
-            return 0;
-        } else {
+/* dict_iter */
+#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+#include <string.h>
+#endif
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
+    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
+    *p_source_is_dict = is_dict;
+    if (is_dict) {
+#if !CYTHON_COMPILING_IN_PYPY
+        *p_orig_length = PyDict_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+#elif PY_MAJOR_VERSION >= 3
+        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
+        PyObject **pp = NULL;
+        if (method_name) {
+            const char *name = PyUnicode_AsUTF8(method_name);
+            if (strcmp(name, "iteritems") == 0) pp = &py_items;
+            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
+            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
+            if (pp) {
+                if (!*pp) {
+                    *pp = PyUnicode_FromString(name + 4);
+                    if (!*pp)
+                        return NULL;
+                }
+                method_name = *pp;
+            }
+        }
+#endif
+    }
+    *p_orig_length = 0;
+    if (method_name) {
+        PyObject* iter;
+        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
+        if (!iterable)
+            return NULL;
+#if !CYTHON_COMPILING_IN_PYPY
+        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
+            return iterable;
+#endif
+        iter = PyObject_GetIter(iterable);
+        Py_DECREF(iterable);
+        return iter;
+    }
+    return PyObject_GetIter(iterable);
+}
+static CYTHON_INLINE int __Pyx_dict_iter_next(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
+    PyObject* next_item;
+#if !CYTHON_COMPILING_IN_PYPY
+    if (source_is_dict) {
+        PyObject *key, *value;
+        if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+            PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
             return -1;
         }
-    }
-    return 0;
-#else
-    if (unlikely(PyErr_Occurred())) {
-        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
-            PyErr_Clear();
+        if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
             return 0;
+        }
+        if (pitem) {
+            PyObject* tuple = PyTuple_New(2);
+            if (unlikely(!tuple)) {
+                return -1;
+            }
+            Py_INCREF(key);
+            Py_INCREF(value);
+            PyTuple_SET_ITEM(tuple, 0, key);
+            PyTuple_SET_ITEM(tuple, 1, value);
+            *pitem = tuple;
         } else {
-            return -1;
+            if (pkey) {
+                Py_INCREF(key);
+                *pkey = key;
+            }
+            if (pvalue) {
+                Py_INCREF(value);
+                *pvalue = value;
+            }
         }
-    }
-    return 0;
+        return 1;
+    } else if (PyTuple_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else if (PyList_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyList_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else
 #endif
+    {
+        next_item = PyIter_Next(iter_obj);
+        if (unlikely(!next_item)) {
+            return __Pyx_IterFinish();
+        }
+    }
+    if (pitem) {
+        *pitem = next_item;
+    } else if (pkey && pvalue) {
+        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
+            return -1;
+    } else if (pkey) {
+        *pkey = next_item;
+    } else {
+        *pvalue = next_item;
+    }
+    return 1;
 }
 
-/* UnpackItemEndCheck */
-static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
-    if (unlikely(retval)) {
-        Py_DECREF(retval);
-        __Pyx_RaiseTooManyValuesError(expected);
-        return -1;
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
     }
-    return __Pyx_IterFinish();
+#endif
+    return 0;
 }
+#endif
 
-/* SliceObject */
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
-        Py_ssize_t cstart, Py_ssize_t cstop,
-        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
-        int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
-#if CYTHON_USE_TYPE_SLOTS
-    PyMappingMethods* mp;
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
 #if PY_MAJOR_VERSION < 3
-    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
-    if (likely(ms && ms->sq_slice)) {
-        if (!has_cstart) {
-            if (_py_start && (*_py_start != Py_None)) {
-                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
-                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
-            } else
-                cstart = 0;
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
-        if (!has_cstop) {
-            if (_py_stop && (*_py_stop != Py_None)) {
-                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
-                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
-            } else
-                cstop = PY_SSIZE_T_MAX;
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
         }
-        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
-            Py_ssize_t l = ms->sq_length(obj);
-            if (likely(l >= 0)) {
-                if (cstop < 0) {
-                    cstop += l;
-                    if (cstop < 0) cstop = 0;
-                }
-                if (cstart < 0) {
-                    cstart += l;
-                    if (cstart < 0) cstart = 0;
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
                 }
-            } else {
-                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
-                    goto bad;
-                PyErr_Clear();
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
             }
         }
-        return ms->sq_slice(obj, cstart, cstop);
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
     }
+    return 0;
+}
 #endif
-    mp = Py_TYPE(obj)->tp_as_mapping;
-    if (likely(mp && mp->mp_subscript))
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
 #endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
     {
-        PyObject* result;
-        PyObject *py_slice, *py_start, *py_stop;
-        if (_py_slice) {
-            py_slice = *_py_slice;
-        } else {
-            PyObject* owned_start = NULL;
-            PyObject* owned_stop = NULL;
-            if (_py_start) {
-                py_start = *_py_start;
-            } else {
-                if (has_cstart) {
-                    owned_start = py_start = PyInt_FromSsize_t(cstart);
-                    if (unlikely(!py_start)) goto bad;
-                } else
-                    py_start = Py_None;
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
             }
-            if (_py_stop) {
-                py_stop = *_py_stop;
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
             } else {
-                if (has_cstop) {
-                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
-                    if (unlikely(!py_stop)) {
-                        Py_XDECREF(owned_start);
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* Import */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *module = 0;
+    PyObject *empty_dict = 0;
+    PyObject *empty_list = 0;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (unlikely(!py_import))
+        goto bad;
+    if (!from_list) {
+        empty_list = PyList_New(0);
+        if (unlikely(!empty_list))
+            goto bad;
+        from_list = empty_list;
+    }
+    #endif
+    empty_dict = PyDict_New();
+    if (unlikely(!empty_dict))
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
+                module = PyImport_ImportModuleLevelObject(
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
                         goto bad;
-                    }
-                } else
-                    py_stop = Py_None;
+                    PyErr_Clear();
+                }
             }
-            py_slice = PySlice_New(py_start, py_stop, Py_None);
-            Py_XDECREF(owned_start);
-            Py_XDECREF(owned_stop);
-            if (unlikely(!py_slice)) goto bad;
+            level = 0;
         }
-#if CYTHON_USE_TYPE_SLOTS
-        result = mp->mp_subscript(obj, py_slice);
+        #endif
+        if (!module) {
+            #if PY_MAJOR_VERSION < 3
+            PyObject *py_level = PyInt_FromLong(level);
+            if (unlikely(!py_level))
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, __pyx_d, empty_dict, from_list, level);
+            #endif
+        }
+    }
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    return module;
+}
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
 #else
-        result = PyObject_GetItem(obj, py_slice);
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
 #endif
-        if (!_py_slice) {
-            Py_DECREF(py_slice);
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
         }
-        return result;
+        goto done;
     }
-    PyErr_Format(PyExc_TypeError,
-        "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
 bad:
-    return NULL;
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
 }
+#endif
 
-/* PyIntBinop */
-#if !CYTHON_COMPILING_IN_PYPY
-static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) {
-    (void)inplace;
-    (void)zerodivision_check;
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_CheckExact(op1))) {
-        const long b = intval;
-        long x;
-        long a = PyInt_AS_LONG(op1);
-            x = (long)((unsigned long)a + b);
-            if (likely((x^a) >= 0 || (x^b) >= 0))
-                return PyInt_FromLong(x);
-            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
     }
-    #endif
-    #if CYTHON_USE_PYLONG_INTERNALS
-    if (likely(PyLong_CheckExact(op1))) {
-        const long b = intval;
-        long a, x;
-#ifdef HAVE_LONG_LONG
-        const PY_LONG_LONG llb = intval;
-        PY_LONG_LONG lla, llx;
-#endif
-        const digit* digits = ((PyLongObject*)op1)->ob_digit;
-        const Py_ssize_t size = Py_SIZE(op1);
-        if (likely(__Pyx_sst_abs(size) <= 1)) {
-            a = likely(size) ? digits[0] : 0;
-            if (size == -1) a = -a;
-        } else {
-            switch (size) {
-                case -2:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 2:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
-#endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case -3:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
 #endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 3:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
 #endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case -4:
-                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
-                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
 #endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                case 4:
-                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
-                        break;
-#ifdef HAVE_LONG_LONG
-                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
-                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
-                        goto long_long;
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
 #endif
-                    }
-                    CYTHON_FALLTHROUGH;
-                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
-            }
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
         }
-                x = a + b;
-            return PyLong_FromLong(x);
-#ifdef HAVE_LONG_LONG
-        long_long:
-                llx = lla + llb;
-            return PyLong_FromLongLong(llx);
 #endif
-        
-        
     }
-    #endif
-    if (PyFloat_CheckExact(op1)) {
-        const long b = intval;
-        double a = PyFloat_AS_DOUBLE(op1);
-            double result;
-            PyFPE_START_PROTECT("add", return NULL)
-            result = ((double)a) + (double)b;
-            PyFPE_END_PROTECT(result)
-            return PyFloat_FromDouble(result);
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
     }
-    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
 }
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
 #endif
-
-/* GetItemInt */
-static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
-    PyObject *r;
-    if (!j) return NULL;
-    r = PyObject_GetItem(o, j);
-    Py_DECREF(j);
-    return r;
-}
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
-                                                              CYTHON_NCP_UNUSED int wraparound,
-                                                              CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    Py_ssize_t wrapped_i = i;
-    if (wraparound & unlikely(i < 0)) {
-        wrapped_i += PyList_GET_SIZE(o);
+        if (unlikely(op->func_name == NULL))
+            return NULL;
     }
-    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
-        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
-        Py_INCREF(r);
-        return r;
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
     }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
-    return PySequence_GetItem(o, i);
+    if (unlikely(value == NULL || !PyString_Check(value)))
 #endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
 }
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
-                                                              CYTHON_NCP_UNUSED int wraparound,
-                                                              CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-    Py_ssize_t wrapped_i = i;
-    if (wraparound & unlikely(i < 0)) {
-        wrapped_i += PyTuple_GET_SIZE(o);
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
     }
-    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
-        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
-        Py_INCREF(r);
-        return r;
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
     }
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
-#else
-    return PySequence_GetItem(o, i);
-#endif
+    #endif
+    Py_DECREF(res);
+    return result;
 }
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
-                                                     CYTHON_NCP_UNUSED int wraparound,
-                                                     CYTHON_NCP_UNUSED int boundscheck) {
-#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
-    if (is_list || PyList_CheckExact(o)) {
-        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
-        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
-            PyObject *r = PyList_GET_ITEM(o, n);
-            Py_INCREF(r);
-            return r;
-        }
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
     }
-    else if (PyTuple_CheckExact(o)) {
-        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
-        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
-            PyObject *r = PyTuple_GET_ITEM(o, n);
-            Py_INCREF(r);
-            return r;
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
         }
-    } else {
-        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
-        if (likely(m && m->sq_item)) {
-            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
-                Py_ssize_t l = m->sq_length(o);
-                if (likely(l >= 0)) {
-                    i += l;
-                } else {
-                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
-                        return NULL;
-                    PyErr_Clear();
-                }
-            }
-            return m->sq_item(o, i);
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
         }
     }
-#else
-    if (is_list || PySequence_Check(o)) {
-        return PySequence_GetItem(o, i);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
     }
-#endif
-    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
 }
-
-/* ObjectGetItem */
-#if CYTHON_USE_TYPE_SLOTS
-static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) {
-    PyObject *runerr = NULL;
-    Py_ssize_t key_value;
-    PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence;
-    if (unlikely(!(m && m->sq_item))) {
-        PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name);
-        return NULL;
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
     }
-    key_value = __Pyx_PyIndex_AsSsize_t(index);
-    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
-        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
     }
-    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
         PyErr_Clear();
-        PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name);
     }
-    return NULL;
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
 }
-static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) {
-    PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping;
-    if (likely(m && m->mp_subscript)) {
-        return m->mp_subscript(obj, key);
-    }
-    return __Pyx_PyObject_GetIndex(obj, key);
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
 }
 #endif
-
-/* BytesEquals */
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
-#if CYTHON_COMPILING_IN_PYPY
-    return PyObject_RichCompareBool(s1, s2, equals);
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
 #else
-    if (s1 == s2) {
-        return (equals == Py_EQ);
-    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
-        const char *ps1, *ps2;
-        Py_ssize_t length = PyBytes_GET_SIZE(s1);
-        if (length != PyBytes_GET_SIZE(s2))
-            return (equals == Py_NE);
-        ps1 = PyBytes_AS_STRING(s1);
-        ps2 = PyBytes_AS_STRING(s2);
-        if (ps1[0] != ps2[0]) {
-            return (equals == Py_NE);
-        } else if (length == 1) {
-            return (equals == Py_EQ);
-        } else {
-            int result;
-#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
-            Py_hash_t hash1, hash2;
-            hash1 = ((PyBytesObject*)s1)->ob_shash;
-            hash2 = ((PyBytesObject*)s2)->ob_shash;
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                return (equals == Py_NE);
-            }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
 #endif
-            result = memcmp(ps1, ps2, (size_t)length);
-            return (equals == Py_EQ) ? (result == 0) : (result != 0);
-        }
-    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
-        return (equals == Py_NE);
-    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
-        return (equals == Py_NE);
-    } else {
-        int result;
-        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
-        if (!py_result)
-            return -1;
-        result = __Pyx_PyObject_IsTrue(py_result);
-        Py_DECREF(py_result);
-        return result;
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
     }
 #endif
+    return (PyObject *) op;
 }
-
-/* UnicodeEquals */
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
-#if CYTHON_COMPILING_IN_PYPY
-    return PyObject_RichCompareBool(s1, s2, equals);
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
 #else
-#if PY_MAJOR_VERSION < 3
-    PyObject* owned_ref = NULL;
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
 #endif
-    int s1_is_unicode, s2_is_unicode;
-    if (s1 == s2) {
-        goto return_eq;
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
     }
-    s1_is_unicode = PyUnicode_CheckExact(s1);
-    s2_is_unicode = PyUnicode_CheckExact(s2);
-#if PY_MAJOR_VERSION < 3
-    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
-        owned_ref = PyUnicode_FromObject(s2);
-        if (unlikely(!owned_ref))
-            return -1;
-        s2 = owned_ref;
-        s2_is_unicode = 1;
-    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
-        owned_ref = PyUnicode_FromObject(s1);
-        if (unlikely(!owned_ref))
-            return -1;
-        s1 = owned_ref;
-        s1_is_unicode = 1;
-    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
-        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
     }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("<cyfunction %s at %p>",
+                               PyString_AsString(op->func_qualname), (void *)op);
 #endif
-    if (s1_is_unicode & s2_is_unicode) {
-        Py_ssize_t length;
-        int kind;
-        void *data1, *data2;
-        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
-            return -1;
-        length = __Pyx_PyUnicode_GET_LENGTH(s1);
-        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
-            goto return_ne;
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
         }
-#if CYTHON_USE_UNICODE_INTERNALS
-        {
-            Py_hash_t hash1, hash2;
-        #if CYTHON_PEP393_ENABLED
-            hash1 = ((PyASCIIObject*)s1)->hash;
-            hash2 = ((PyASCIIObject*)s2)->hash;
-        #else
-            hash1 = ((PyUnicodeObject*)s1)->hash;
-            hash2 = ((PyUnicodeObject*)s2)->hash;
-        #endif
-            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
-                goto return_ne;
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
             }
-        }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
 #endif
-        kind = __Pyx_PyUnicode_KIND(s1);
-        if (kind != __Pyx_PyUnicode_KIND(s2)) {
-            goto return_ne;
-        }
-        data1 = __Pyx_PyUnicode_DATA(s1);
-        data2 = __Pyx_PyUnicode_DATA(s2);
-        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
-            goto return_ne;
-        } else if (length == 1) {
-            goto return_eq;
-        } else {
-            int result = memcmp(data1, data2, (size_t)(length * kind));
-            #if PY_MAJOR_VERSION < 3
-            Py_XDECREF(owned_ref);
-            #endif
-            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+            return NULL;
         }
-    } else if ((s1 == Py_None) & s2_is_unicode) {
-        goto return_ne;
-    } else if ((s2 == Py_None) & s1_is_unicode) {
-        goto return_ne;
-    } else {
-        int result;
-        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
-        #if PY_MAJOR_VERSION < 3
-        Py_XDECREF(owned_ref);
-        #endif
-        if (!py_result)
-            return -1;
-        result = __Pyx_PyObject_IsTrue(py_result);
-        Py_DECREF(py_result);
-        return result;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
     }
-return_eq:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(owned_ref);
-    #endif
-    return (equals == Py_EQ);
-return_ne:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(owned_ref);
-    #endif
-    return (equals == Py_NE);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
 #endif
+    return NULL;
 }
-
-/* PyObjectCallNoArg */
-#if CYTHON_COMPILING_IN_CPYTHON
-static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
-#if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(func)) {
-        return __Pyx_PyFunction_FastCall(func, NULL, 0);
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
     }
 #endif
-#if defined(__Pyx_CyFunction_USED) && defined(NDEBUG)
-    if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func)))
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
 #else
-    if (likely(PyCFunction_Check(func)))
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
 #endif
-    {
-        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
-            return __Pyx_PyObject_CallMethO(func, NULL);
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
         }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
     }
-    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+    return result;
 }
-#endif
-
-/* None */
-static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
-    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
 }
-
-/* None */
-static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) {
-    PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname);
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
 }
-
-/* PyIntCompare */
-static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) {
-    if (op1 == op2) {
-        Py_RETURN_TRUE;
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
     }
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_CheckExact(op1))) {
-        const long b = intval;
-        long a = PyInt_AS_LONG(op1);
-        if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
     }
-    #endif
-    #if CYTHON_USE_PYLONG_INTERNALS
-    if (likely(PyLong_CheckExact(op1))) {
-        int unequal;
-        unsigned long uintval;
-        Py_ssize_t size = Py_SIZE(op1);
-        const digit* digits = ((PyLongObject*)op1)->ob_digit;
-        if (intval == 0) {
-            if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
-        } else if (intval < 0) {
-            if (size >= 0)
-                Py_RETURN_FALSE;
-            intval = -intval;
-            size = -size;
-        } else {
-            if (size <= 0)
-                Py_RETURN_FALSE;
-        }
-        uintval = (unsigned long) intval;
-#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 4)) {
-            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
 #endif
-#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 3)) {
-            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
 #endif
-#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 2)) {
-            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
 #endif
-#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
-        if (uintval >> (PyLong_SHIFT * 1)) {
-            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
-                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
-        } else
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
 #endif
-            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
-        if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE;
-    }
-    #endif
-    if (PyFloat_CheckExact(op1)) {
-        const long b = intval;
-        double a = PyFloat_AS_DOUBLE(op1);
-        if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE;
-    }
-    return (
-        PyObject_RichCompare(op1, op2, Py_EQ));
-}
-
-/* PyNumberPow2 */
-static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) {
-#if !CYTHON_COMPILING_IN_PYPY
-    Py_ssize_t shiftby;
+    0,
+    0,
 #if PY_MAJOR_VERSION < 3
-    if (likely(PyInt_CheckExact(exp))) {
-        shiftby = PyInt_AS_LONG(exp);
-    } else
+    0,
+#else
+    0,
 #endif
-    if (likely(PyLong_CheckExact(exp))) {
-        #if CYTHON_USE_PYLONG_INTERNALS
-        const Py_ssize_t size = Py_SIZE(exp);
-        if (likely(size == 1)) {
-            shiftby = ((PyLongObject*)exp)->ob_digit[0];
-        } else if (size == 0) {
-            return PyInt_FromLong(1L);
-        } else if (unlikely(size < 0)) {
-            goto fallback;
-        } else {
-            shiftby = PyLong_AsSsize_t(exp);
-        }
-        #else
-        shiftby = PyLong_AsSsize_t(exp);
-        #endif
-    } else {
-        goto fallback;
-    }
-    if (likely(shiftby >= 0)) {
-        if ((size_t)shiftby <= sizeof(long) * 8 - 2) {
-            long value = 1L << shiftby;
-            return PyInt_FromLong(value);
-#ifdef HAVE_LONG_LONG
-        } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) {
-            unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby;
-            return PyLong_FromUnsignedLongLong(value);
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
 #endif
-        } else {
-            PyObject *result, *one = PyInt_FromLong(1L);
-            if (unlikely(!one)) return NULL;
-            result = PyNumber_Lshift(one, exp);
-            Py_DECREF(one);
-            return result;
-        }
-    } else if (shiftby == -1 && PyErr_Occurred()) {
-        PyErr_Clear();
-    }
-fallback:
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
 #endif
-    return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none);
-}
-
-/* PyErrFetchRestore */
-#if CYTHON_FAST_THREAD_STATE
-static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
-    PyObject *tmp_type, *tmp_value, *tmp_tb;
-    tmp_type = tstate->curexc_type;
-    tmp_value = tstate->curexc_value;
-    tmp_tb = tstate->curexc_traceback;
-    tstate->curexc_type = type;
-    tstate->curexc_value = value;
-    tstate->curexc_traceback = tb;
-    Py_XDECREF(tmp_type);
-    Py_XDECREF(tmp_value);
-    Py_XDECREF(tmp_tb);
-}
-static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    *type = tstate->curexc_type;
-    *value = tstate->curexc_value;
-    *tb = tstate->curexc_traceback;
-    tstate->curexc_type = 0;
-    tstate->curexc_value = 0;
-    tstate->curexc_traceback = 0;
-}
+};
 #endif
-
-/* IterNext */
-static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) {
-    PyObject* exc_type;
-    __Pyx_PyThreadState_declare
-    __Pyx_PyThreadState_assign
-    exc_type = __Pyx_PyErr_Occurred();
-    if (unlikely(exc_type)) {
-        if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
-            return NULL;
-        __Pyx_PyErr_Clear();
-        Py_INCREF(defval);
-        return defval;
-    }
-    if (defval) {
-        Py_INCREF(defval);
-        return defval;
-    }
-    __Pyx_PyErr_SetNone(PyExc_StopIteration);
-    return NULL;
-}
-static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) {
-    PyErr_Format(PyExc_TypeError,
-        "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name);
-}
-static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
-    PyObject* next;
-    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
-    if (likely(iternext)) {
-#if CYTHON_USE_TYPE_SLOTS
-        next = iternext(iterator);
-        if (likely(next))
-            return next;
-        #if PY_VERSION_HEX >= 0x02070000
-        if (unlikely(iternext == &_PyObject_NextNotImplemented))
-            return NULL;
-        #endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
 #else
-        next = PyIter_Next(iterator);
-        if (likely(next))
-            return next;
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
 #endif
-    } else if (CYTHON_USE_TYPE_SLOTS || unlikely(!PyIter_Check(iterator))) {
-        __Pyx_PyIter_Next_ErrorNoIterator(iterator);
-        return NULL;
-    }
-#if !CYTHON_USE_TYPE_SLOTS
-    else {
-        next = PyIter_Next(iterator);
-        if (likely(next))
-            return next;
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
     }
-#endif
-    return __Pyx_PyIter_Next2Default(defval);
+    return 0;
 }
-
-/* PyObject_GenericGetAttrNoDict */
-#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
-static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, attr_name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(attr_name));
-#endif
-    return NULL;
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
 }
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
-    PyObject *descr;
-    PyTypeObject *tp = Py_TYPE(obj);
-    if (unlikely(!PyString_Check(attr_name))) {
-        return PyObject_GenericGetAttr(obj, attr_name);
-    }
-    assert(!tp->tp_dictoffset);
-    descr = _PyType_Lookup(tp, attr_name);
-    if (unlikely(!descr)) {
-        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
-    }
-    Py_INCREF(descr);
-    #if PY_MAJOR_VERSION < 3
-    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
-    #endif
-    {
-        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
-        if (unlikely(f)) {
-            PyObject *res = f(descr, obj, (PyObject *)tp);
-            Py_DECREF(descr);
-            return res;
-        }
-    }
-    return descr;
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
 }
-#endif
 
-/* Import */
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
-    PyObject *empty_list = 0;
-    PyObject *module = 0;
-    PyObject *global_dict = 0;
-    PyObject *empty_dict = 0;
-    PyObject *list;
-    #if PY_MAJOR_VERSION < 3
-    PyObject *py_import;
-    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
-    if (!py_import)
-        goto bad;
-    #endif
-    if (from_list)
-        list = from_list;
-    else {
-        empty_list = PyList_New(0);
-        if (!empty_list)
-            goto bad;
-        list = empty_list;
-    }
-    global_dict = PyModule_GetDict(__pyx_m);
-    if (!global_dict)
-        goto bad;
-    empty_dict = PyDict_New();
-    if (!empty_dict)
-        goto bad;
-    {
-        #if PY_MAJOR_VERSION >= 3
-        if (level == -1) {
-            if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) {
-                module = PyImport_ImportModuleLevelObject(
-                    name, global_dict, empty_dict, list, 1);
-                if (!module) {
-                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
-                        goto bad;
-                    PyErr_Clear();
-                }
-            }
-            level = 0;
-        }
-        #endif
-        if (!module) {
-            #if PY_MAJOR_VERSION < 3
-            PyObject *py_level = PyInt_FromLong(level);
-            if (!py_level)
-                goto bad;
-            module = PyObject_CallFunctionObjArgs(py_import,
-                name, global_dict, empty_dict, list, py_level, (PyObject *)NULL);
-            Py_DECREF(py_level);
-            #else
-            module = PyImport_ImportModuleLevelObject(
-                name, global_dict, empty_dict, list, level);
-            #endif
-        }
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
     }
-bad:
-    #if PY_MAJOR_VERSION < 3
-    Py_XDECREF(py_import);
-    #endif
-    Py_XDECREF(empty_list);
-    Py_XDECREF(empty_dict);
-    return module;
+    return op;
 }
 
 /* CLineInTraceback */
 #ifndef CYTHON_CLINE_IN_TRACEBACK
-static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) {
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
     PyObject *use_cline;
     PyObject *ptype, *pvalue, *ptraceback;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject **cython_runtime_dict;
 #endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
     if (unlikely(!__pyx_cython_runtime)) {
         return c_line;
     }
@@ -7711,7 +14675,7 @@ static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_li
     } else
 #endif
     {
-      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
       if (use_cline_obj) {
         use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
         Py_DECREF(use_cline_obj);
@@ -7733,6 +14697,7 @@ static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_li
 #endif
 
 /* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
     int start = 0, mid = 0, end = count - 1;
     if (end >= 0 && code_line > entries[end].code_line) {
@@ -7811,17 +14776,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
     __pyx_code_cache.count++;
     Py_INCREF(code_object);
 }
+#endif
 
 /* AddTraceback */
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
   #include "internal/pycore_frame.h"
 #endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
@@ -7856,6 +14905,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
         0,
         0,
         0,
+        0,
         __pyx_empty_bytes, /*PyObject *code,*/
         __pyx_empty_tuple, /*PyObject *consts,*/
         __pyx_empty_tuple, /*PyObject *names,*/
@@ -7871,7 +14921,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
     #else
     py_code = PyCode_NewEmpty(filename, funcname, py_line);
     #endif
-    Py_XDECREF(py_funcname);  // XDECREF since it's only set on Py3 if cline
+    Py_XDECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_funcname);
@@ -7918,6 +14968,23 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line,
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
+#endif
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__29);
+    }
+    return name;
+}
+#endif
 
 /* CIntToPy */
 static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
@@ -7952,8 +15019,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
     {
         int one = 1; int little = (int)*(unsigned char *)&one;
         unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
         return _PyLong_FromByteArray(bytes, sizeof(long),
                                      little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
     }
 }
 
@@ -7992,7 +15085,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(long) < sizeof(long)) {
+        if ((sizeof(long) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8006,40 +15099,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
     if (likely(PyLong_Check(x))) {
         if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
-                case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
-                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
+                                return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
                         }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
-                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        break;
+                    case 3:
+                        if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
+                                return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
                         }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
-                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        break;
+                    case 4:
+                        if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
+                                return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
                         }
-                    }
-                    break;
+                        break;
+                }
             }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
             if (unlikely(Py_SIZE(x) < 0)) {
                 goto raise_neg_overflow;
             }
@@ -8052,109 +15150,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
                     goto raise_neg_overflow;
             }
 #endif
-            if (sizeof(long) <= sizeof(unsigned long)) {
+            if ((sizeof(long) <= sizeof(unsigned long))) {
                 __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
                 __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
             }
         } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (long) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
-                case -2:
-                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 2:
-                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        break;
+                    case 2:
+                        if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                                return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case -3:
-                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        break;
+                    case -3:
+                        if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        break;
+                    case 3:
+                        if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                                return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case -4:
-                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        break;
+                    case -4:
+                        if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
-                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        break;
+                    case 4:
+                        if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                                return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
                         }
-                    }
-                    break;
+                        break;
+                }
             }
 #endif
-            if (sizeof(long) <= sizeof(long)) {
+            if ((sizeof(long) <= sizeof(long))) {
                 __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
                 __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
             }
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
             long val;
             PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
+#if PY_MAJOR_VERSION < 3
             if (likely(v) && !PyLong_Check(v)) {
                 PyObject *tmp = v;
                 v = PyNumber_Long(tmp);
                 Py_DECREF(tmp);
             }
- #endif
+#endif
             if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
                 int one = 1; int is_little = (int)*(unsigned char *)&one;
                 unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (long) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (long) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (long) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (long) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (long) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((long) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((long) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
                 Py_DECREF(v);
                 if (likely(!ret))
                     return val;
             }
-#endif
             return (long) -1;
         }
     } else {
@@ -8188,7 +15358,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     const int is_unsigned = neg_one > const_zero;
 #if PY_MAJOR_VERSION < 3
     if (likely(PyInt_Check(x))) {
-        if (sizeof(int) < sizeof(long)) {
+        if ((sizeof(int) < sizeof(long))) {
             __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
         } else {
             long val = PyInt_AS_LONG(x);
@@ -8202,40 +15372,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
     if (likely(PyLong_Check(x))) {
         if (is_unsigned) {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
-                case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
-                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
+                                return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
                         }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
-                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        break;
+                    case 3:
+                        if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
+                                return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
                         }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
-                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        break;
+                    case 4:
+                        if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
+                                return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
                         }
-                    }
-                    break;
+                        break;
+                }
             }
 #endif
-#if CYTHON_COMPILING_IN_CPYTHON
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
             if (unlikely(Py_SIZE(x) < 0)) {
                 goto raise_neg_overflow;
             }
@@ -8248,109 +15423,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
                     goto raise_neg_overflow;
             }
 #endif
-            if (sizeof(int) <= sizeof(unsigned long)) {
+            if ((sizeof(int) <= sizeof(unsigned long))) {
                 __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
                 __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
 #endif
             }
         } else {
 #if CYTHON_USE_PYLONG_INTERNALS
-            const digit* digits = ((PyLongObject*)x)->ob_digit;
-            switch (Py_SIZE(x)) {
-                case  0: return (int) 0;
-                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
-                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
-                case -2:
-                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 2:
-                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        break;
+                    case 2:
+                        if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case -3:
-                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        break;
+                    case -3:
+                        if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 3:
-                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        break;
+                    case 3:
+                        if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case -4:
-                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
-                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        break;
+                    case -4:
+                        if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
-                case 4:
-                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
-                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
-                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
-                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
-                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        break;
+                    case 4:
+                        if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
                         }
-                    }
-                    break;
+                        break;
+                }
             }
 #endif
-            if (sizeof(int) <= sizeof(long)) {
+            if ((sizeof(int) <= sizeof(long))) {
                 __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
 #ifdef HAVE_LONG_LONG
-            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
                 __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
 #endif
             }
         }
         {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
-            PyErr_SetString(PyExc_RuntimeError,
-                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
             int val;
             PyObject *v = __Pyx_PyNumber_IntOrLong(x);
- #if PY_MAJOR_VERSION < 3
+#if PY_MAJOR_VERSION < 3
             if (likely(v) && !PyLong_Check(v)) {
                 PyObject *tmp = v;
                 v = PyNumber_Long(tmp);
                 Py_DECREF(tmp);
             }
- #endif
+#endif
             if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
                 int one = 1; int is_little = (int)*(unsigned char *)&one;
                 unsigned char *bytes = (unsigned char *)&val;
-                int ret = _PyLong_AsByteArray((PyLongObject *)v,
-                                              bytes, sizeof(val),
-                                              is_little, !is_unsigned);
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (int) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (int) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (int) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (int) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (int) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((int) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((int) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
                 Py_DECREF(v);
                 if (likely(!ret))
                     return val;
             }
-#endif
             return (int) -1;
         }
     } else {
@@ -8375,7 +15622,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
 #if CYTHON_COMPILING_IN_CPYTHON
 static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
     while (a) {
-        a = a->tp_base;
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
         if (a == b)
             return 1;
     }
@@ -8396,6 +15643,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
     }
     return __Pyx_InBases(a, b);
 }
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
 #if PY_MAJOR_VERSION == 2
 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
     PyObject *exception, *value, *tb;
@@ -8420,11 +15683,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc
 }
 #else
 static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
-    int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0;
-    if (!res) {
-        res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
     }
-    return res;
 }
 #endif
 static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
@@ -8439,243 +15702,45 @@ static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *
     for (i=0; i<n; i++) {
         PyObject *t = PyTuple_GET_ITEM(tuple, i);
         #if PY_MAJOR_VERSION < 3
-        if (likely(exc_type == t)) return 1;
-        #endif
-        if (likely(PyExceptionClass_Check(t))) {
-            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
-        } else {
-        }
-    }
-    return 0;
-}
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
-    if (likely(err == exc_type)) return 1;
-    if (likely(PyExceptionClass_Check(err))) {
-        if (likely(PyExceptionClass_Check(exc_type))) {
-            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
-        } else if (likely(PyTuple_Check(exc_type))) {
-            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
-        } else {
-        }
-    }
-    return PyErr_GivenExceptionMatches(err, exc_type);
-}
-static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
-    assert(PyExceptionClass_Check(exc_type1));
-    assert(PyExceptionClass_Check(exc_type2));
-    if (likely(err == exc_type1 || err == exc_type2)) return 1;
-    if (likely(PyExceptionClass_Check(err))) {
-        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
-    }
-    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
-}
-#endif
-
-/* FetchCommonType */
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
-    PyObject* fake_module;
-    PyTypeObject* cached_type = NULL;
-    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
-    if (!fake_module) return NULL;
-    Py_INCREF(fake_module);
-    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
-    if (cached_type) {
-        if (!PyType_Check((PyObject*)cached_type)) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s is not a type object",
-                type->tp_name);
-            goto bad;
-        }
-        if (cached_type->tp_basicsize != type->tp_basicsize) {
-            PyErr_Format(PyExc_TypeError,
-                "Shared Cython type %.200s has the wrong size, try recompiling",
-                type->tp_name);
-            goto bad;
-        }
-    } else {
-        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
-        PyErr_Clear();
-        if (PyType_Ready(type) < 0) goto bad;
-        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
-            goto bad;
-        Py_INCREF(type);
-        cached_type = type;
-    }
-done:
-    Py_DECREF(fake_module);
-    return cached_type;
-bad:
-    Py_XDECREF(cached_type);
-    cached_type = NULL;
-    goto done;
-}
-
-/* RaiseException */
-#if PY_MAJOR_VERSION < 3
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
-                        CYTHON_UNUSED PyObject *cause) {
-    __Pyx_PyThreadState_declare
-    Py_XINCREF(type);
-    if (!value || value == Py_None)
-        value = NULL;
-    else
-        Py_INCREF(value);
-    if (!tb || tb == Py_None)
-        tb = NULL;
-    else {
-        Py_INCREF(tb);
-        if (!PyTraceBack_Check(tb)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: arg 3 must be a traceback or None");
-            goto raise_error;
-        }
-    }
-    if (PyType_Check(type)) {
-#if CYTHON_COMPILING_IN_PYPY
-        if (!value) {
-            Py_INCREF(Py_None);
-            value = Py_None;
-        }
-#endif
-        PyErr_NormalizeException(&type, &value, &tb);
-    } else {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto raise_error;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(type);
-        Py_INCREF(type);
-        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
-            PyErr_SetString(PyExc_TypeError,
-                "raise: exception class must be a subclass of BaseException");
-            goto raise_error;
-        }
-    }
-    __Pyx_PyThreadState_assign
-    __Pyx_ErrRestore(type, value, tb);
-    return;
-raise_error:
-    Py_XDECREF(value);
-    Py_XDECREF(type);
-    Py_XDECREF(tb);
-    return;
-}
-#else
-static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
-    PyObject* owned_instance = NULL;
-    if (tb == Py_None) {
-        tb = 0;
-    } else if (tb && !PyTraceBack_Check(tb)) {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: arg 3 must be a traceback or None");
-        goto bad;
-    }
-    if (value == Py_None)
-        value = 0;
-    if (PyExceptionInstance_Check(type)) {
-        if (value) {
-            PyErr_SetString(PyExc_TypeError,
-                "instance exception may not have a separate value");
-            goto bad;
-        }
-        value = type;
-        type = (PyObject*) Py_TYPE(value);
-    } else if (PyExceptionClass_Check(type)) {
-        PyObject *instance_class = NULL;
-        if (value && PyExceptionInstance_Check(value)) {
-            instance_class = (PyObject*) Py_TYPE(value);
-            if (instance_class != type) {
-                int is_subclass = PyObject_IsSubclass(instance_class, type);
-                if (!is_subclass) {
-                    instance_class = NULL;
-                } else if (unlikely(is_subclass == -1)) {
-                    goto bad;
-                } else {
-                    type = instance_class;
-                }
-            }
-        }
-        if (!instance_class) {
-            PyObject *args;
-            if (!value)
-                args = PyTuple_New(0);
-            else if (PyTuple_Check(value)) {
-                Py_INCREF(value);
-                args = value;
-            } else
-                args = PyTuple_Pack(1, value);
-            if (!args)
-                goto bad;
-            owned_instance = PyObject_Call(type, args, NULL);
-            Py_DECREF(args);
-            if (!owned_instance)
-                goto bad;
-            value = owned_instance;
-            if (!PyExceptionInstance_Check(value)) {
-                PyErr_Format(PyExc_TypeError,
-                             "calling %R should have returned an instance of "
-                             "BaseException, not %R",
-                             type, Py_TYPE(value));
-                goto bad;
-            }
-        }
-    } else {
-        PyErr_SetString(PyExc_TypeError,
-            "raise: exception class must be a subclass of BaseException");
-        goto bad;
-    }
-    if (cause) {
-        PyObject *fixed_cause;
-        if (cause == Py_None) {
-            fixed_cause = NULL;
-        } else if (PyExceptionClass_Check(cause)) {
-            fixed_cause = PyObject_CallObject(cause, NULL);
-            if (fixed_cause == NULL)
-                goto bad;
-        } else if (PyExceptionInstance_Check(cause)) {
-            fixed_cause = cause;
-            Py_INCREF(fixed_cause);
+        if (likely(exc_type == t)) return 1;
+        #endif
+        if (likely(PyExceptionClass_Check(t))) {
+            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
         } else {
-            PyErr_SetString(PyExc_TypeError,
-                            "exception causes must derive from "
-                            "BaseException");
-            goto bad;
         }
-        PyException_SetCause(value, fixed_cause);
     }
-    PyErr_SetObject(type, value);
-    if (tb) {
-#if CYTHON_FAST_THREAD_STATE
-        PyThreadState *tstate = __Pyx_PyThreadState_Current;
-        PyObject* tmp_tb = tstate->curexc_traceback;
-        if (tb != tmp_tb) {
-            Py_INCREF(tb);
-            tstate->curexc_traceback = tb;
-            Py_XDECREF(tmp_tb);
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
+    if (likely(err == exc_type)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        if (likely(PyExceptionClass_Check(exc_type))) {
+            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
+        } else if (likely(PyTuple_Check(exc_type))) {
+            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
+        } else {
         }
-#else
-        PyObject *tmp_type, *tmp_value, *tmp_tb;
-        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
-        Py_INCREF(tb);
-        PyErr_Restore(tmp_type, tmp_value, tb);
-        Py_XDECREF(tmp_tb);
-#endif
     }
-bad:
-    Py_XDECREF(owned_instance);
-    return;
+    return PyErr_GivenExceptionMatches(err, exc_type);
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
+    assert(PyExceptionClass_Check(exc_type1));
+    assert(PyExceptionClass_Check(exc_type2));
+    if (likely(err == exc_type1 || err == exc_type2)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
+    }
+    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
 }
 #endif
 
 /* GetTopmostException */
-#if CYTHON_USE_EXC_INFO_STACK
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
 static _PyErr_StackItem *
 __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 {
     _PyErr_StackItem *exc_info = tstate->exc_info;
-    while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) &&
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
            exc_info->previous_item != NULL)
     {
         exc_info = exc_info->previous_item;
@@ -8687,21 +15752,46 @@ __Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
 /* SaveResetException */
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
     *type = exc_info->exc_type;
     *value = exc_info->exc_value;
     *tb = exc_info->exc_traceback;
-    #else
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
-    #endif
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
+  #endif
 }
 static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     #if CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
@@ -8722,6 +15812,7 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
+  #endif
 }
 #endif
 
@@ -8729,7 +15820,26 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject
 #if CYTHON_FAST_THREAD_STATE
 static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
-    #if CYTHON_USE_EXC_INFO_STACK
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
     _PyErr_StackItem *exc_info = tstate->exc_info;
     tmp_type = exc_info->exc_type;
     tmp_value = exc_info->exc_value;
@@ -8737,14 +15847,14 @@ static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject *
     exc_info->exc_type = *type;
     exc_info->exc_value = *value;
     exc_info->exc_traceback = *tb;
-    #else
+  #else
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
-    #endif
+  #endif
     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
@@ -8760,109 +15870,28 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value,
 }
 #endif
 
-/* PyObjectGetMethod */
-static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
-    PyObject *attr;
-#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
-    PyTypeObject *tp = Py_TYPE(obj);
-    PyObject *descr;
-    descrgetfunc f = NULL;
-    PyObject **dictptr, *dict;
-    int meth_found = 0;
-    assert (*method == NULL);
-    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
-        attr = __Pyx_PyObject_GetAttrStr(obj, name);
-        goto try_unpack;
-    }
-    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
-        return 0;
-    }
-    descr = _PyType_Lookup(tp, name);
-    if (likely(descr != NULL)) {
-        Py_INCREF(descr);
-#if PY_MAJOR_VERSION >= 3
-        #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
-        #else
-        if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type)))
-        #endif
-#else
-        #ifdef __Pyx_CyFunction_USED
-        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
-        #else
-        if (likely(PyFunction_Check(descr)))
-        #endif
-#endif
-        {
-            meth_found = 1;
-        } else {
-            f = Py_TYPE(descr)->tp_descr_get;
-            if (f != NULL && PyDescr_IsData(descr)) {
-                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
-                Py_DECREF(descr);
-                goto try_unpack;
-            }
-        }
-    }
-    dictptr = _PyObject_GetDictPtr(obj);
-    if (dictptr != NULL && (dict = *dictptr) != NULL) {
-        Py_INCREF(dict);
-        attr = __Pyx_PyDict_GetItemStr(dict, name);
-        if (attr != NULL) {
-            Py_INCREF(attr);
-            Py_DECREF(dict);
-            Py_XDECREF(descr);
-            goto try_unpack;
-        }
-        Py_DECREF(dict);
-    }
-    if (meth_found) {
-        *method = descr;
-        return 1;
-    }
-    if (f != NULL) {
-        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
-        Py_DECREF(descr);
-        goto try_unpack;
-    }
-    if (descr != NULL) {
-        *method = descr;
-        return 0;
-    }
-    PyErr_Format(PyExc_AttributeError,
-#if PY_MAJOR_VERSION >= 3
-                 "'%.50s' object has no attribute '%U'",
-                 tp->tp_name, name);
-#else
-                 "'%.50s' object has no attribute '%.400s'",
-                 tp->tp_name, PyString_AS_STRING(name));
-#endif
-    return 0;
-#else
-    attr = __Pyx_PyObject_GetAttrStr(obj, name);
-    goto try_unpack;
-#endif
-try_unpack:
-#if CYTHON_UNPACK_METHODS
-    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
-        PyObject *function = PyMethod_GET_FUNCTION(attr);
-        Py_INCREF(function);
-        Py_DECREF(attr);
-        *method = function;
-        return 1;
-    }
-#endif
-    *method = attr;
-    return 0;
+/* PyObjectCall2Args */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args[3] = {NULL, arg1, arg2};
+    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
 }
 
 /* PyObjectCallMethod1 */
+#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2)
 static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
     PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
     Py_DECREF(method);
     return result;
 }
+#endif
 static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2
+    PyObject *args[2] = {obj, arg};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_Call2Args;
+    return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
     PyObject *method = NULL, *result;
     int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
     if (likely(is_method)) {
@@ -8872,10 +15901,10 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name
     }
     if (unlikely(!method)) return NULL;
     return __Pyx__PyObject_CallMethod1(method, arg);
+#endif
 }
 
 /* CoroutineBase */
-#include <structmember.h>
 #include <frameobject.h>
 #if PY_VERSION_HEX >= 0x030b00a6
   #ifndef Py_BUILD_CORE
@@ -8884,9 +15913,10 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name
   #include "internal/pycore_frame.h"
 #endif
 #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom)
-static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) {
+static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) {
     PyObject *et, *ev, *tb;
     PyObject *value = NULL;
+    CYTHON_UNUSED_VAR(__pyx_tstate);
     __Pyx_ErrFetch(&et, &ev, &tb);
     if (!et) {
         Py_XDECREF(tb);
@@ -8901,7 +15931,7 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p
             value = Py_None;
         }
 #if PY_VERSION_HEX >= 0x030300A0
-        else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) {
+        else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) {
             value = ((PyStopIterationObject *)ev)->value;
             Py_INCREF(value);
             Py_DECREF(ev);
@@ -8965,6 +15995,9 @@ static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__p
 }
 static CYTHON_INLINE
 void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_CLEAR(exc_state->exc_value);
+#else
     PyObject *t, *v, *tb;
     t = exc_state->exc_type;
     v = exc_state->exc_value;
@@ -8975,10 +16008,12 @@ void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
     Py_XDECREF(t);
     Py_XDECREF(v);
     Py_XDECREF(tb);
+#endif
 }
 #define __Pyx_Coroutine_AlreadyRunningError(gen)  (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL)
-static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) {
+static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) {
     const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if ((0)) {
     #ifdef __Pyx_Coroutine_USED
     } else if (__Pyx_Coroutine_Check((PyObject*)gen)) {
@@ -8994,8 +16029,9 @@ static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineOb
     PyErr_SetString(PyExc_ValueError, msg);
 }
 #define __Pyx_Coroutine_NotStartedError(gen)  (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL)
-static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) {
+static void __Pyx__Coroutine_NotStartedError(PyObject *gen) {
     const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if ((0)) {
     #ifdef __Pyx_Coroutine_USED
     } else if (__Pyx_Coroutine_Check(gen)) {
@@ -9011,7 +16047,9 @@ static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) {
     PyErr_SetString(PyExc_TypeError, msg);
 }
 #define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing)  (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL)
-static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) {
+static void __Pyx__Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    CYTHON_MAYBE_UNUSED_VAR(closing);
     #ifdef __Pyx_Coroutine_USED
     if (!closing && __Pyx_Coroutine_Check(gen)) {
         PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine");
@@ -9048,11 +16086,19 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     tstate = __Pyx_PyThreadState_Current;
 #endif
     exc_state = &self->gi_exc_state;
-    if (exc_state->exc_type) {
-        #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON
+    if (exc_state->exc_value) {
+        #if CYTHON_COMPILING_IN_PYPY
+        #else
+        PyObject *exc_tb;
+        #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+        exc_tb = PyException_GetTraceback(exc_state->exc_value);
+        #elif PY_VERSION_HEX >= 0x030B00a4
+        exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback;
         #else
-        if (exc_state->exc_traceback) {
-            PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback;
+        exc_tb = exc_state->exc_traceback;
+        #endif
+        if (exc_tb) {
+            PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
             PyFrameObject *f = tb->tb_frame;
             assert(f->f_back == NULL);
             #if PY_VERSION_HEX >= 0x030B00A1
@@ -9061,6 +16107,9 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
             Py_XINCREF(tstate->frame);
             f->f_back = tstate->frame;
             #endif
+            #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+            Py_DECREF(exc_tb);
+            #endif
         }
         #endif
     }
@@ -9076,7 +16125,7 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     }
 #endif
     self->is_running = 1;
-    retval = self->body((PyObject *) self, tstate, value);
+    retval = self->body(self, tstate, value);
     self->is_running = 0;
 #if CYTHON_USE_EXC_INFO_STACK
     exc_state = &self->gi_exc_state;
@@ -9087,18 +16136,29 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, i
     return retval;
 }
 static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) {
-    PyObject *exc_tb = exc_state->exc_traceback;
-    if (likely(exc_tb)) {
-#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON
+#if CYTHON_COMPILING_IN_PYPY
+    CYTHON_UNUSED_VAR(exc_state);
 #else
+    PyObject *exc_tb;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    if (!exc_state->exc_value) return;
+    exc_tb = PyException_GetTraceback(exc_state->exc_value);
+    #else
+    exc_tb = exc_state->exc_traceback;
+    #endif
+    if (likely(exc_tb)) {
         PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
         PyFrameObject *f = tb->tb_frame;
         Py_CLEAR(f->f_back);
-#endif
+        #if PY_VERSION_HEX >= 0x030B00a4
+        Py_DECREF(exc_tb);
+        #endif
     }
+#endif
 }
 static CYTHON_INLINE
-PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) {
+PyObject *__Pyx_Coroutine_MethodReturn(PyObject* gen, PyObject *retval) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
     if (unlikely(!retval)) {
         __Pyx_PyThreadState_declare
         __Pyx_PyThreadState_assign
@@ -9129,9 +16189,22 @@ PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) {
             PyErr_SetNone(PyExc_StopIteration);
         }
         else {
+#if PY_VERSION_HEX < 0x030d00A1
             _PyGen_SetStopIterationValue(result);
+#else
+            if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) {
+                PyErr_SetObject(PyExc_StopIteration, result);
+            } else {
+                PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result);
+                if (likely(exc != NULL)) {
+                    PyErr_SetObject(PyExc_StopIteration, exc);
+                    Py_DECREF(exc);
+                }
+            }
+#endif
         }
-        Py_CLEAR(result);
+        Py_DECREF(result);
+        result = NULL;
     }
     return result;
 #endif
@@ -9183,7 +16256,7 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) {
         #endif
         {
             if (value == Py_None)
-                ret = Py_TYPE(yf)->tp_iternext(yf);
+                ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
             else
                 ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value);
         }
@@ -9230,16 +16303,15 @@ static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) {
     {
         PyObject *meth;
         gen->is_running = 1;
-        meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close);
+        meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_close);
         if (unlikely(!meth)) {
-            if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+            if (unlikely(PyErr_Occurred())) {
                 PyErr_WriteUnraisable(yf);
             }
-            PyErr_Clear();
         } else {
-            retval = PyObject_CallFunction(meth, NULL);
+            retval = __Pyx_PyObject_CallNoArg(meth);
             Py_DECREF(meth);
-            if (!retval)
+            if (unlikely(!retval))
                 err = -1;
         }
         gen->is_running = 0;
@@ -9270,7 +16342,7 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) {
             ret = __Pyx_Coroutine_Send(yf, Py_None);
         } else
         #endif
-            ret = Py_TYPE(yf)->tp_iternext(yf);
+            ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
         gen->is_running = 0;
         if (likely(ret)) {
             return ret;
@@ -9279,7 +16351,8 @@ static PyObject *__Pyx_Generator_Next(PyObject *self) {
     }
     return __Pyx_Coroutine_SendEx(gen, Py_None, 0);
 }
-static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) {
+static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) {
+    CYTHON_UNUSED_VAR(arg);
     return __Pyx_Coroutine_Close(self);
 }
 static PyObject *__Pyx_Coroutine_Close(PyObject *self) {
@@ -9360,22 +16433,22 @@ static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject
             ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit);
         #endif
         } else {
-            PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw);
+            PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_throw);
             if (unlikely(!meth)) {
                 Py_DECREF(yf);
-                if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                if (unlikely(PyErr_Occurred())) {
                     gen->is_running = 0;
                     return NULL;
                 }
-                PyErr_Clear();
                 __Pyx_Coroutine_Undelegate(gen);
                 gen->is_running = 0;
                 goto throw_here;
             }
             if (likely(args)) {
-                ret = PyObject_CallObject(meth, args);
+                ret = __Pyx_PyObject_Call(meth, args, NULL);
             } else {
-                ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL);
+                PyObject *cargs[4] = {NULL, typ, val, tb};
+                ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
             }
             Py_DECREF(meth);
         }
@@ -9394,14 +16467,18 @@ static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) {
     PyObject *typ;
     PyObject *val = NULL;
     PyObject *tb = NULL;
-    if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb))
+    if (unlikely(!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)))
         return NULL;
     return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1);
 }
 static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_VISIT(exc_state->exc_value);
+#else
     Py_VISIT(exc_state->exc_type);
     Py_VISIT(exc_state->exc_value);
     Py_VISIT(exc_state->exc_traceback);
+#endif
     return 0;
 }
 static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) {
@@ -9436,10 +16513,10 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) {
     if (gen->resume_label >= 0) {
         PyObject_GC_Track(self);
 #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE
-        if (PyObject_CallFinalizerFromDealloc(self))
+        if (unlikely(PyObject_CallFinalizerFromDealloc(self)))
 #else
         Py_TYPE(gen)->tp_del(self);
-        if (Py_REFCNT(self) > 0)
+        if (unlikely(Py_REFCNT(self) > 0))
 #endif
         {
             return;
@@ -9455,7 +16532,7 @@ static void __Pyx_Coroutine_dealloc(PyObject *self) {
     }
 #endif
     __Pyx_Coroutine_clear(self);
-    PyObject_GC_Del(gen);
+    __Pyx_PyHeapTypeObject_GC_Del(gen);
 }
 static void __Pyx_Coroutine_del(PyObject *self) {
     PyObject *error_type, *error_value, *error_traceback;
@@ -9534,7 +16611,7 @@ static void __Pyx_Coroutine_del(PyObject *self) {
     __Pyx_ErrRestore(error_type, error_value, error_traceback);
 #if !CYTHON_USE_TP_FINALIZE
     assert(Py_REFCNT(self) > 0);
-    if (--self->ob_refcnt == 0) {
+    if (likely(--self->ob_refcnt == 0)) {
         return;
     }
     {
@@ -9554,17 +16631,18 @@ static void __Pyx_Coroutine_del(PyObject *self) {
 #endif
 }
 static PyObject *
-__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *name = self->gi_name;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!name)) name = Py_None;
     Py_INCREF(name);
     return name;
 }
 static int
-__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -9575,24 +16653,23 @@ __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UN
                         "__name__ must be set to a string object");
         return -1;
     }
-    tmp = self->gi_name;
     Py_INCREF(value);
-    self->gi_name = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(self->gi_name, value);
     return 0;
 }
 static PyObject *
-__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *name = self->gi_qualname;
+    CYTHON_UNUSED_VAR(context);
     if (unlikely(!name)) name = Py_None;
     Py_INCREF(name);
     return name;
 }
 static int
-__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context)
 {
-    PyObject *tmp;
+    CYTHON_UNUSED_VAR(context);
 #if PY_MAJOR_VERSION >= 3
     if (unlikely(value == NULL || !PyUnicode_Check(value)))
 #else
@@ -9603,16 +16680,15 @@ __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHO
                         "__qualname__ must be set to a string object");
         return -1;
     }
-    tmp = self->gi_qualname;
     Py_INCREF(value);
-    self->gi_qualname = value;
-    Py_XDECREF(tmp);
+    __Pyx_Py_XDECREF_SET(self->gi_qualname, value);
     return 0;
 }
 static PyObject *
-__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context)
+__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context)
 {
     PyObject *frame = self->gi_frame;
+    CYTHON_UNUSED_VAR(context);
     if (!frame) {
         if (unlikely(!self->gi_code)) {
             Py_RETURN_NONE;
@@ -9648,9 +16724,13 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
     gen->resume_label = 0;
     gen->classobj = NULL;
     gen->yieldfrom = NULL;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    gen->gi_exc_state.exc_value = NULL;
+    #else
     gen->gi_exc_state.exc_type = NULL;
     gen->gi_exc_state.exc_value = NULL;
     gen->gi_exc_state.exc_traceback = NULL;
+    #endif
 #if CYTHON_USE_EXC_INFO_STACK
     gen->gi_exc_state.previous_item = NULL;
 #endif
@@ -9735,7 +16815,7 @@ static int __Pyx_patch_abc(void) {
     if (CYTHON_REGISTER_ABCS && !abc_patched) {
         PyObject *module;
         module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections");
-        if (!module) {
+        if (unlikely(!module)) {
             PyErr_WriteUnraisable(NULL);
             if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning,
                     ((PY_MAJOR_VERSION >= 3) ?
@@ -9780,6 +16860,10 @@ static PyMemberDef __pyx_Generator_memberlist[] = {
     {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
      (char*) PyDoc_STR("object being iterated by 'yield from', or None")},
     {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL},
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0},
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0},
+#endif
     {0, 0, 0, 0, 0}
 };
 static PyGetSetDef __pyx_Generator_getsets[] = {
@@ -9791,9 +16875,32 @@ static PyGetSetDef __pyx_Generator_getsets[] = {
      (char*) PyDoc_STR("Frame of the generator"), 0},
     {0, 0, 0, 0, 0}
 };
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_GeneratorType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc},
+    {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse},
+    {Py_tp_iter, (void *)PyObject_SelfIter},
+    {Py_tp_iternext, (void *)__Pyx_Generator_Next},
+    {Py_tp_methods, (void *)__pyx_Generator_methods},
+    {Py_tp_members, (void *)__pyx_Generator_memberlist},
+    {Py_tp_getset, (void *)__pyx_Generator_getsets},
+    {Py_tp_getattro, (void *) __Pyx_PyObject_GenericGetAttrNoDict},
+#if CYTHON_USE_TP_FINALIZE
+    {Py_tp_finalize, (void *)__Pyx_Coroutine_del},
+#endif
+    {0, 0},
+};
+static PyType_Spec __pyx_GeneratorType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "generator",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    __pyx_GeneratorType_slots
+};
+#else
 static PyTypeObject __pyx_GeneratorType_type = {
     PyVarObject_HEAD_INIT(0, 0)
-    "generator",
+    __PYX_TYPE_MODULE_PREFIX "generator",
     sizeof(__pyx_CoroutineObject),
     0,
     (destructor) __Pyx_Coroutine_dealloc,
@@ -9851,17 +16958,26 @@ static PyTypeObject __pyx_GeneratorType_type = {
 #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
     0,
 #endif
-#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
     0,
 #endif
-#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
     0,
 #endif
 };
-static int __pyx_Generator_init(void) {
+#endif
+static int __pyx_Generator_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_GeneratorType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
     __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
     __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter;
     __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type);
+#endif
     if (unlikely(!__pyx_GeneratorType)) {
         return -1;
     }
@@ -9875,47 +16991,78 @@ static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) {
 }
 
 /* CheckBinaryVersion */
-static int __Pyx_check_binary_version(void) {
-    char ctversion[5];
-    int same=1, i, found_dot;
-    const char* rt_from_call = Py_GetVersion();
-    PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
-    found_dot = 0;
-    for (i = 0; i < 4; i++) {
-        if (!ctversion[i]) {
-            same = (rt_from_call[i] < '0' || rt_from_call[i] > '9');
-            break;
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
         }
-        if (rt_from_call[i] != ctversion[i]) {
-            same = 0;
+        version += factor * digit;
+        if (rt_version[i] != '.')
             break;
-        }
+        digit = 0;
+        factor >>= 8;
+        ++i;
     }
-    if (!same) {
-        char rtversion[5] = {'\0'};
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
         char message[200];
-        for (i=0; i<4; ++i) {
-            if (rt_from_call[i] == '.') {
-                if (found_dot) break;
-                found_dot = 1;
-            } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') {
-                break;
-            }
-            rtversion[i] = rt_from_call[i];
-        }
         PyOS_snprintf(message, sizeof(message),
-                      "compiletime version %s of module '%.100s' "
-                      "does not match runtime version %s",
-                      ctversion, __Pyx_MODULE_NAME, rtversion);
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
         return PyErr_WarnEx(NULL, message, 1);
     }
-    return 0;
 }
 
 /* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
     while (t->p) {
-        #if PY_MAJOR_VERSION < 3
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
         if (t->is_unicode) {
             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
         } else if (t->intern) {
@@ -9923,30 +17070,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
         } else {
             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
         }
-        #else
-        if (t->is_unicode | t->is_str) {
-            if (t->intern) {
-                *t->p = PyUnicode_InternFromString(t->s);
-            } else if (t->encoding) {
-                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
-            } else {
-                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
-            }
-        } else {
-            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
-        }
-        #endif
         if (!*t->p)
             return -1;
         if (PyObject_Hash(*t->p) == -1)
             return -1;
+        #endif
         ++t;
     }
     return 0;
 }
 
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
 static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
-    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
 }
 static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
     Py_ssize_t ignore;
@@ -10001,7 +17152,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_
         return __Pyx_PyUnicode_AsStringAndSize(o, length);
     } else
 #endif
-#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
     if (PyByteArray_Check(o)) {
         *length = PyByteArray_GET_SIZE(o);
         return PyByteArray_AS_STRING(o);
@@ -10030,22 +17181,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
     return retval;
 }
 static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
 #if PY_MAJOR_VERSION >= 3
     if (PyLong_Check(result)) {
         if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
-                "__int__ returned non-int (type %.200s).  "
-                "The ability to return an instance of a strict subclass of int "
-                "is deprecated, and may be removed in a future version of Python.",
-                Py_TYPE(result)->tp_name)) {
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
             Py_DECREF(result);
             return NULL;
         }
+        __Pyx_DECREF_TypeName(result_type_name);
         return result;
     }
 #endif
     PyErr_Format(PyExc_TypeError,
-                 "__%.4s__ returned non-%.4s (type %.200s)",
-                 type_name, type_name, Py_TYPE(result)->tp_name);
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
     Py_DECREF(result);
     return NULL;
 }
@@ -10111,13 +17266,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
 #endif
   if (likely(PyLong_CheckExact(b))) {
     #if CYTHON_USE_PYLONG_INTERNALS
-    const digit* digits = ((PyLongObject*)b)->ob_digit;
-    const Py_ssize_t size = Py_SIZE(b);
-    if (likely(__Pyx_sst_abs(size) <= 1)) {
-        ival = likely(size) ? digits[0] : 0;
-        if (size == -1) ival = -ival;
-        return ival;
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
     } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
       switch (size) {
          case 2:
            if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
@@ -10185,4 +17338,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
 }
 
 
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
 #endif /* Py_PYTHON_H */
diff --git a/cana/canalization/cboolean_canalization.pyx b/cana/canalization/cboolean_canalization.pyx
index 3486891..fd7d281 100644
--- a/cana/canalization/cboolean_canalization.pyx
+++ b/cana/canalization/cboolean_canalization.pyx
@@ -12,6 +12,8 @@ Functions to compute the Quine-McCluskey algorithm in cython for increaed comput
 #
 #   All rights reserved.
 #   MIT license.
+import cython
+
 from cana.cutils import *
 
 WILDCARD_SYMBOL = '#'
@@ -134,16 +136,180 @@ def find_implicants_qm(input_binstates, verbose=False):
     return prime_implicants
 
 
-def __pi_covers(implicant, binstate):
-    """Determines if a binarystate is covered by a specific implicant.
-    Args:
-        implicant (string): the implicant.
-        minterm (string): the minterm.
-    Returns:
-        x (bool): True if covered else False.
+@cython.cfunc
+cdef inline bint _is_wildcard_symbol(object symbol):
+    return (
+        symbol == WILDCARD_SYMBOL
+        or symbol == SYMMETRIC_WILDCARD_SYMBOL
+        or symbol == '2'
+        or symbol == 2
+    )
 
-    """
-    return all(i == WILDCARD_SYMBOL or m == i for i, m in zip(implicant, input))
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef bint pi_covers_fast(object implicant, object binstate):
+    """Fast coverage check for wildcard schemata."""
+    cdef list imp_list
+    cdef Py_ssize_t i, n
+    cdef object symbol
+    cdef str binstate_str = <str>binstate
+
+    if isinstance(implicant, str):
+        imp_list = list(implicant)
+    else:
+        imp_list = [x for x in implicant]
+
+    n = len(imp_list)
+    if len(binstate_str) != n:
+        raise ValueError("Implicant and binstate must have the same length")
+
+    for i in range(n):
+        symbol = imp_list[i]
+        if symbol == binstate_str[i]:
+            continue
+        if _is_wildcard_symbol(symbol):
+            continue
+        return False
+    return True
+
+
+@cython.cfunc
+cdef list _normalize_index_groups(object groups):
+    if not groups:
+        return []
+    cdef list normalized = []
+    cdef object group
+    cdef object idx
+    for group in groups:
+        if not group:
+            normalized.append([])
+            continue
+        normalized.append([int(idx) for idx in group])
+    return normalized
+
+
+@cython.cfunc
+cdef list _init_implicant_stack(object two_symbol):
+    cdef list stack = []
+    cdef object item
+    if isinstance(two_symbol, str):
+        stack.append(list(two_symbol))
+    else:
+        for item in two_symbol:
+            if isinstance(item, str):
+                stack.append(list(item))
+            else:
+                stack.append([c for c in item])
+    return stack
+
+
+@cython.cfunc
+cdef void _permute_assign(
+    list base_implicant,
+    list idxs,
+    list chars,
+    Py_ssize_t pos,
+    Py_ssize_t n,
+    list stack,
+    set seen,
+):
+    cdef Py_ssize_t i
+    cdef object tmp
+    cdef dict used
+
+    if pos == n:
+        new_implicant = base_implicant[:]
+        for i in range(n):
+            new_implicant[idxs[i]] = chars[i]
+        tmp = tuple(new_implicant)
+        if tmp not in seen:
+            stack.append(new_implicant)
+        return
+
+    used = {}
+    for i in range(pos, n):
+        tmp = chars[i]
+        if tmp in used:
+            continue
+        used[tmp] = None
+        chars[pos], chars[i] = chars[i], chars[pos]
+        _permute_assign(base_implicant, idxs, chars, pos + 1, n, stack, seen)
+        chars[pos], chars[i] = chars[i], chars[pos]
+
+
+@cython.cfunc
+cdef void _enqueue_permutations(list base_implicant, list idxs, list stack, set seen):
+    cdef Py_ssize_t n = len(idxs)
+    if n <= 1:
+        return
+    chars = [base_implicant[i] for i in idxs]
+    _permute_assign(base_implicant, idxs, chars, 0, n, stack, seen)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef list expand_ts_logic_fast(object two_symbols, object permut_indexes):
+    """Generate all permutations for two-symbol schemata groups."""
+    cdef list idx_groups = _normalize_index_groups(permut_indexes)
+    if not idx_groups:
+        return _init_implicant_stack(two_symbols)
+
+    cdef list stack = _init_implicant_stack(two_symbols)
+    cdef list results = []
+    cdef set seen = set()
+    cdef list implicant
+    cdef tuple key
+    cdef list idxs
+
+    while stack:
+        implicant = <list>stack.pop()
+        key = tuple(implicant)
+        if key in seen:
+            continue
+        seen.add(key)
+        results.append(list(implicant))
+        for idxs in idx_groups:
+            if not idxs:
+                continue
+            _enqueue_permutations(implicant, idxs, stack, seen)
+
+    return results
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cpdef bint ts_covers_fast(object two_symbol, object permut_indexes, object binstate):
+    """Fast coverage test for two-symbol schemata with permutations."""
+    cdef list idx_groups = _normalize_index_groups(permut_indexes)
+    if not idx_groups:
+        return pi_covers_fast(two_symbol, binstate)
+
+    cdef list stack = _init_implicant_stack(two_symbol)
+    cdef set seen = set()
+    cdef list implicant
+    cdef tuple key
+    cdef list idxs
+
+    while stack:
+        implicant = <list>stack.pop()
+        key = tuple(implicant)
+        if key in seen:
+            continue
+        seen.add(key)
+        if pi_covers_fast(implicant, binstate):
+            return True
+        for idxs in idx_groups:
+            if not idxs:
+                continue
+            _enqueue_permutations(implicant, idxs, stack, seen)
+
+    return False
+
+
+def __pi_covers(implicant, binstate):
+    """Determine if a binarystate is covered by a specific implicant."""
+    return pi_covers_fast(implicant, binstate)
 
 
 def expand_wildcard_schemata(schemata):
diff --git a/cana/cboolean_node.c b/cana/cboolean_node.c
new file mode 100644
index 0000000..b0f5cd0
--- /dev/null
+++ b/cana/cboolean_node.c
@@ -0,0 +1,9641 @@
+/* Generated by Cython 3.2.0 */
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+/* InitLimitedAPI */
+#if defined(Py_LIMITED_API)
+  #if !defined(CYTHON_LIMITED_API)
+  #define CYTHON_LIMITED_API 1
+  #endif
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef _MSC_VER
+  #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.")
+  #else
+  #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.
+  #endif
+#endif
+
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x03080000
+    #error Cython requires Python 3.8+.
+#else
+#define __PYX_ABI_VERSION "3_2_0"
+#define CYTHON_HEX_VERSION 0x030200F0
+#define CYTHON_FUTURE_DIVISION 1
+/* CModulePreamble */
+#include <stddef.h>
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX
+#if defined(GRAALVM_PYTHON)
+  /* For very preliminary testing purposes. Most variables are set the same as PyPy.
+     The existence of this section does not imply that anything works or is even tested */
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 1
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 0
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_ASSUME_SAFE_SIZE
+  #define CYTHON_ASSUME_SAFE_SIZE 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #undef CYTHON_PEP489_MULTI_PHASE_INIT
+  #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
+  #undef CYTHON_USE_TP_FINALIZE
+  #define CYTHON_USE_TP_FINALIZE 0
+  #undef CYTHON_USE_AM_SEND
+  #define CYTHON_USE_AM_SEND 0
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 1
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+  #undef CYTHON_IMMORTAL_CONSTANTS
+  #define CYTHON_IMMORTAL_CONSTANTS 0
+#elif defined(PYPY_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 1
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #ifndef CYTHON_ASSUME_SAFE_SIZE
+    #define CYTHON_ASSUME_SAFE_SIZE 1
+  #endif
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #if PY_VERSION_HEX < 0x03090000
+    #undef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+  #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT)
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #undef CYTHON_USE_MODULE_STATE
+  #define CYTHON_USE_MODULE_STATE 0
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00)
+  #endif
+  #undef CYTHON_USE_AM_SEND
+  #define CYTHON_USE_AM_SEND 0
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100)
+  #endif
+  #undef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 0
+  #undef CYTHON_IMMORTAL_CONSTANTS
+  #define CYTHON_IMMORTAL_CONSTANTS 0
+#elif defined(CYTHON_LIMITED_API)
+  #ifdef Py_LIMITED_API
+    #undef __PYX_LIMITED_VERSION_HEX
+    #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API
+  #endif
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #define CYTHON_COMPILING_IN_LIMITED_API 1
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_TYPE_SPECS
+  #define CYTHON_USE_TYPE_SPECS 1
+  #undef CYTHON_USE_PYTYPE_LOOKUP
+  #define CYTHON_USE_PYTYPE_LOOKUP 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #endif
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
+  #endif
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_ASSUME_SAFE_SIZE
+  #define CYTHON_ASSUME_SAFE_SIZE 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_GIL
+  #define CYTHON_FAST_GIL 0
+  #undef CYTHON_METH_FASTCALL
+  #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #undef CYTHON_USE_SYS_MONITORING
+  #define CYTHON_USE_SYS_MONITORING 0
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 0
+  #endif
+  #ifndef CYTHON_USE_AM_SEND
+    #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000)
+  #endif
+  #undef CYTHON_USE_DICT_VERSIONS
+  #define CYTHON_USE_DICT_VERSIONS 0
+  #undef CYTHON_USE_EXC_INFO_STACK
+  #define CYTHON_USE_EXC_INFO_STACK 0
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 0
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+  #define CYTHON_USE_FREELISTS 1
+  #endif
+  #undef CYTHON_IMMORTAL_CONSTANTS
+  #define CYTHON_IMMORTAL_CONSTANTS 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #define CYTHON_COMPILING_IN_LIMITED_API 0
+  #define CYTHON_COMPILING_IN_GRAAL 0
+  #ifdef Py_GIL_DISABLED
+    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1
+  #else
+    #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0
+  #endif
+  #if PY_VERSION_HEX < 0x030A0000
+    #undef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #elif !defined(CYTHON_USE_TYPE_SLOTS)
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #ifndef CYTHON_USE_TYPE_SPECS
+    #define CYTHON_USE_TYPE_SPECS 0
+  #endif
+  #ifndef CYTHON_USE_PYTYPE_LOOKUP
+    #define CYTHON_USE_PYTYPE_LOOKUP 1
+  #endif
+  #ifndef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLIST_INTERNALS)
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1
+  #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)
+    #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_SIZE
+    #define CYTHON_ASSUME_SAFE_SIZE 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_FAST_GIL
+    #define CYTHON_FAST_GIL 0
+  #elif !defined(CYTHON_FAST_GIL)
+    #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6)
+  #endif
+  #ifndef CYTHON_METH_FASTCALL
+    #define CYTHON_METH_FASTCALL 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+  #ifndef CYTHON_PEP487_INIT_SUBCLASS
+    #define CYTHON_PEP487_INIT_SUBCLASS 1
+  #endif
+  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+    #define CYTHON_PEP489_MULTI_PHASE_INIT 1
+  #endif
+  #ifndef CYTHON_USE_MODULE_STATE
+    #define CYTHON_USE_MODULE_STATE 0
+  #endif
+  #ifndef CYTHON_USE_SYS_MONITORING
+    #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1)
+  #endif
+  #ifndef CYTHON_USE_TP_FINALIZE
+    #define CYTHON_USE_TP_FINALIZE 1
+  #endif
+  #ifndef CYTHON_USE_AM_SEND
+    #define CYTHON_USE_AM_SEND 1
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    #undef CYTHON_USE_DICT_VERSIONS
+    #define CYTHON_USE_DICT_VERSIONS 0
+  #elif !defined(CYTHON_USE_DICT_VERSIONS)
+    #define CYTHON_USE_DICT_VERSIONS  (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE)
+  #endif
+  #ifndef CYTHON_USE_EXC_INFO_STACK
+    #define CYTHON_USE_EXC_INFO_STACK 1
+  #endif
+  #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC
+    #define CYTHON_UPDATE_DESCRIPTOR_DOC 1
+  #endif
+  #ifndef CYTHON_USE_FREELISTS
+    #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING)
+  #endif
+  #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000
+    #undef CYTHON_IMMORTAL_CONSTANTS
+    #define CYTHON_IMMORTAL_CONSTANTS 0  // definitely won't work
+  #elif !defined(CYTHON_IMMORTAL_CONSTANTS)
+    #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING)
+  #endif
+#endif
+#ifndef CYTHON_COMPRESS_STRINGS
+  #define CYTHON_COMPRESS_STRINGS 1
+#endif
+#ifndef CYTHON_FAST_PYCCALL
+#define CYTHON_FAST_PYCCALL  CYTHON_FAST_PYCALL
+#endif
+#ifndef CYTHON_VECTORCALL
+#if CYTHON_COMPILING_IN_LIMITED_API
+#define CYTHON_VECTORCALL  (__PYX_LIMITED_VERSION_HEX >= 0x030C0000)
+#else
+#define CYTHON_VECTORCALL  (CYTHON_FAST_PYCCALL)
+#endif
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+  #ifdef SIZEOF_VOID_P
+    enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+  #endif
+#endif
+#ifndef __has_attribute
+  #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+  #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(maybe_unused)
+        #define CYTHON_UNUSED [[maybe_unused]]
+      #endif
+    #endif
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+  #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x)
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_USE_CPP_STD_MOVE
+  #if defined(__cplusplus) && (\
+    __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600))
+    #define CYTHON_USE_CPP_STD_MOVE 1
+  #else
+    #define CYTHON_USE_CPP_STD_MOVE 0
+  #endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+#include <stdint.h>
+typedef uintptr_t  __pyx_uintptr_t;
+#ifndef CYTHON_FALLTHROUGH
+  #if defined(__cplusplus)
+    /* for clang __has_cpp_attribute(fallthrough) is true even before C++17
+     * but leads to warnings with -pedantic, since it is a C++17 feature */
+    #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+      #if __has_cpp_attribute(fallthrough)
+        #define CYTHON_FALLTHROUGH [[fallthrough]]
+      #endif
+    #endif
+    #ifndef CYTHON_FALLTHROUGH
+      #if __has_cpp_attribute(clang::fallthrough)
+        #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+      #elif __has_cpp_attribute(gnu::fallthrough)
+        #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+      #endif
+    #endif
+  #endif
+  #ifndef CYTHON_FALLTHROUGH
+    #if __has_attribute(fallthrough)
+      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+    #else
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+  #if defined(__clang__) && defined(__apple_build_version__)
+    #if __apple_build_version__ < 7000000
+      #undef  CYTHON_FALLTHROUGH
+      #define CYTHON_FALLTHROUGH
+    #endif
+  #endif
+#endif
+#ifndef Py_UNREACHABLE
+  #define Py_UNREACHABLE()  assert(0); abort()
+#endif
+#ifdef __cplusplus
+  template <typename T>
+  struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);};
+  #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL<type>::value)
+#else
+  #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0)
+#endif
+#if CYTHON_COMPILING_IN_PYPY == 1
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX < 0x030A0000)
+#else
+  #define __PYX_NEED_TP_PRINT_SLOT  (PY_VERSION_HEX < 0x03090000)
+#endif
+#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer))
+
+/* CInitCode */
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #elif defined(__GNUC__)
+    #define CYTHON_INLINE __inline__
+  #elif defined(_MSC_VER)
+    #define CYTHON_INLINE __inline
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_INLINE inline
+  #else
+    #define CYTHON_INLINE
+  #endif
+#endif
+
+/* PythonCompatibility */
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#define __Pyx_DefaultClassType PyType_Type
+#if CYTHON_COMPILING_IN_LIMITED_API
+    #ifndef CO_OPTIMIZED
+    static int CO_OPTIMIZED;
+    #endif
+    #ifndef CO_NEWLOCALS
+    static int CO_NEWLOCALS;
+    #endif
+    #ifndef CO_VARARGS
+    static int CO_VARARGS;
+    #endif
+    #ifndef CO_VARKEYWORDS
+    static int CO_VARKEYWORDS;
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+    static int CO_ASYNC_GENERATOR;
+    #endif
+    #ifndef CO_GENERATOR
+    static int CO_GENERATOR;
+    #endif
+    #ifndef CO_COROUTINE
+    static int CO_COROUTINE;
+    #endif
+#else
+    #ifndef CO_COROUTINE
+      #define CO_COROUTINE 0x80
+    #endif
+    #ifndef CO_ASYNC_GENERATOR
+      #define CO_ASYNC_GENERATOR 0x200
+    #endif
+#endif
+static int __Pyx_init_co_variables(void);
+#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE)
+  #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type)
+#else
+  #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is)
+  #define __Pyx_Py_Is(x, y)  Py_Is(x, y)
+#else
+  #define __Pyx_Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone)
+  #define __Pyx_Py_IsNone(ob) Py_IsNone(ob)
+#else
+  #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue)
+  #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob)
+#else
+  #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True)
+#endif
+#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse)
+  #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob)
+#else
+  #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False)
+#endif
+#define __Pyx_NoneAsNull(obj)  (__Pyx_Py_IsNone(obj) ? NULL : (obj))
+#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o)
+#else
+  #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o)
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef Py_TPFLAGS_SEQUENCE
+  #define Py_TPFLAGS_SEQUENCE 0
+#endif
+#ifndef Py_TPFLAGS_MAPPING
+  #define Py_TPFLAGS_MAPPING 0
+#endif
+#ifndef Py_TPFLAGS_IMMUTABLETYPE
+  #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8)
+#endif
+#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION
+  #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7)
+#endif
+#ifndef METH_STACKLESS
+  #define METH_STACKLESS 0
+#endif
+#ifndef METH_FASTCALL
+  #ifndef METH_FASTCALL
+     #define METH_FASTCALL 0x80
+  #endif
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+                                                          Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #if PY_VERSION_HEX >= 0x030d00A4
+  #  define __Pyx_PyCFunctionFast PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords
+  #else
+  #  define __Pyx_PyCFunctionFast _PyCFunctionFast
+  #  define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+  #endif
+#endif
+#if CYTHON_METH_FASTCALL
+  #define __Pyx_METH_FASTCALL METH_FASTCALL
+  #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast
+  #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords
+#else
+  #define __Pyx_METH_FASTCALL METH_VARARGS
+  #define __Pyx_PyCFunction_FastCall PyCFunction
+  #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords
+#endif
+#if CYTHON_VECTORCALL
+  #define __pyx_vectorcallfunc vectorcallfunc
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  PY_VECTORCALL_ARGUMENTS_OFFSET
+  #define __Pyx_PyVectorcall_NARGS(n)  PyVectorcall_NARGS((size_t)(n))
+#else
+  #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET  0
+  #define __Pyx_PyVectorcall_NARGS(n)  ((Py_ssize_t)(n))
+#endif
+#if PY_VERSION_HEX >= 0x030900B1
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_CheckExact(func)
+#else
+#define __Pyx_PyCFunction_CheckExact(func)  PyCFunction_Check(func)
+#endif
+#define __Pyx_CyOrPyCFunction_Check(func)  PyCFunction_Check(func)
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  (((PyCFunctionObject*)(func))->m_ml->ml_meth)
+#elif !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func)  PyCFunction_GET_FUNCTION(func)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_CyOrPyCFunction_GET_FLAGS(func)  (((PyCFunctionObject*)(func))->m_ml->ml_flags)
+static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) {
+    return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self;
+}
+#endif
+static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+#else
+    return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+#endif
+}
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCFunction(func, cfunc)
+#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000)
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  ((void)m, PyType_FromSpecWithBases(s, b))
+  typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *);
+#else
+  #define __Pyx_PyType_FromModuleAndSpec(m, s, b)  PyType_FromModuleAndSpec(m, s, b)
+  #define __Pyx_PyCMethod  PyCMethod
+#endif
+#ifndef METH_METHOD
+  #define METH_METHOD 0x200
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)
+#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno))
+#elif CYTHON_COMPILING_IN_GRAAL
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno))
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyThreadState_Current PyThreadState_Get()
+#elif !CYTHON_FAST_THREAD_STATE
+  #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x030d00A1
+  #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked()
+#else
+  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#endif
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op)
+{
+    void *result;
+    result = PyModule_GetState(op);
+    if (!result)
+        Py_FatalError("Couldn't find the module state");
+    return result;
+}
+#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o)
+#else
+#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global)
+#endif
+#define __Pyx_PyObject_GetSlot(obj, name, func_ctype)  __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype)
+#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype)
+#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
+#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype)
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((type)->name)
+  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype)
+  #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL)
+  #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype)
+#else
+  #define __Pyx_PyType_GetSlot(type, name, func_ctype)  ((func_ctype) PyType_GetSlot((type), Py_##name))
+  #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\
+    ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\
+     (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\
+     __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL)
+  #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype)
+  #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
+#endif
+#define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+#define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStrWithError(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) {
+    PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name);
+    if (res == NULL) PyErr_Clear();
+    return res;
+}
+#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000
+#define __Pyx_PyDict_GetItemStrWithError  PyDict_GetItemWithError
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#else
+static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) {
+#if CYTHON_COMPILING_IN_PYPY
+    return PyDict_GetItem(dict, name);
+#else
+    PyDictEntry *ep;
+    PyDictObject *mp = (PyDictObject*) dict;
+    long hash = ((PyStringObject *) name)->ob_shash;
+    assert(hash != -1);
+    ep = (mp->ma_lookup)(mp, name, hash);
+    if (ep == NULL) {
+        return NULL;
+    }
+    return ep->me_value;
+#endif
+}
+#define __Pyx_PyDict_GetItemStr           PyDict_GetItem
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+  #define __Pyx_PyType_GetFlags(tp)   (((PyTypeObject *)tp)->tp_flags)
+  #define __Pyx_PyType_HasFeature(type, feature)  ((__Pyx_PyType_GetFlags(type) & (feature)) != 0)
+#else
+  #define __Pyx_PyType_GetFlags(tp)   (PyType_GetFlags((PyTypeObject *)tp))
+  #define __Pyx_PyType_HasFeature(type, feature)  PyType_HasFeature(type, feature)
+#endif
+#define __Pyx_PyObject_GetIterNextFunc(iterator)  __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc)
+#if CYTHON_USE_TYPE_SPECS
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  {\
+    PyTypeObject *type = Py_TYPE((PyObject*)obj);\
+    assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\
+    PyObject_GC_Del(obj);\
+    Py_DECREF(type);\
+}
+#else
+#define __Pyx_PyHeapTypeObject_GC_Del(obj)  PyObject_GC_Del(obj)
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((void)u, 1114111U)
+  #define __Pyx_PyUnicode_KIND(u)         ((void)u, (0))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)k, PyUnicode_ReadChar((PyObject*)(d), i))
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GetLength(u))
+#else
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_READY(op)       (0)
+  #else
+    #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                                0 : _PyUnicode_Ready((PyObject *)(op)))
+  #endif
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         ((int)PyUnicode_KIND(u))
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, (Py_UCS4) ch)
+  #if PY_VERSION_HEX >= 0x030C0000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_LENGTH(u))
+  #else
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length))
+    #else
+    #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+    #endif
+  #endif
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #if !defined(PyUnicode_DecodeUnicodeEscape)
+    #define PyUnicode_DecodeUnicodeEscape(s, size, errors)  PyUnicode_Decode(s, size, "unicode_escape", errors)
+  #endif
+  #if !defined(PyUnicode_Contains)
+    #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+  #endif
+  #if !defined(PyByteArray_Check)
+    #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+  #endif
+  #if !defined(PyObject_Format)
+    #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+  #endif
+#endif
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#elif CYTHON_COMPILING_IN_CPYTHON
+  #define __Pyx_PySequence_ListKeepNew(obj)\
+    (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj))
+#else
+  #define __Pyx_PySequence_ListKeepNew(obj)  PySequence_List(obj)
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        __Pyx_IS_TYPE(obj, &PySet_Type)
+#endif
+#if PY_VERSION_HEX >= 0x030900A4
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size)
+#else
+  #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt)
+  #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size)
+#endif
+enum __Pyx_ReferenceSharing {
+  __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check
+  __Pyx_ReferenceSharing_OwnStrongReference,
+  __Pyx_ReferenceSharing_FunctionArgument,
+  __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar
+};
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000
+#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\
+    (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\
+      (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\
+      (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0)))
+#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1)
+#else
+#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0)
+#endif
+#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
+  #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+  #else
+    #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i)
+  #endif
+#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS
+  #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i)
+  #else
+    #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i))
+  #endif
+#else
+  #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i))
+#endif
+#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !CYTHON_COMPILING_IN_LIMITED_API && CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) (__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\
+    __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i))
+#else
+  #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) __Pyx_PyList_GetItemRef(o, i)
+#endif
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result)
+#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS
+static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
+  *result = PyObject_GetItem(dict, key);
+  if (*result == NULL) {
+    if (PyErr_ExceptionMatches(PyExc_KeyError)) {
+      PyErr_Clear();
+      return 0;
+    }
+    return -1;
+  }
+  return 1;
+}
+#else
+static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) {
+  *result = PyDict_GetItemWithError(dict, key);
+  if (*result == NULL) {
+    return PyErr_Occurred() ? -1 : 0;
+  }
+  Py_INCREF(*result);
+  return 1;
+}
+#endif
+#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST
+  #define __Pyx_VISIT_CONST(obj)  Py_VISIT(obj)
+#else
+  #define __Pyx_VISIT_CONST(obj)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i)
+  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0))
+  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i)
+#else
+  #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i)
+  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
+  #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v)
+  #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i)
+  #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v)
+  #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i)
+#endif
+#if CYTHON_ASSUME_SAFE_SIZE
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o)
+  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o)
+#else
+  #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o)
+  #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o)
+  #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o)
+  #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o)
+  #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o)
+  #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString)
+  #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+#endif
+#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t
+#define __Pyx_PyLong_AsHash_t   __Pyx_PyIndex_AsSsize_t
+#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000
+    #define __Pyx_PySendResult PySendResult
+#else
+    typedef enum {
+        PYGEN_RETURN = 0,
+        PYGEN_ERROR = -1,
+        PYGEN_NEXT = 1,
+    } __Pyx_PySendResult;
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3
+  typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result);
+#else
+  #define __Pyx_pyiter_sendfunc sendfunc
+#endif
+#if !CYTHON_USE_AM_SEND
+#define __PYX_HAS_PY_AM_SEND 0
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000
+#define __PYX_HAS_PY_AM_SEND 1
+#else
+#define __PYX_HAS_PY_AM_SEND 2  // our own backported implementation
+#endif
+#if __PYX_HAS_PY_AM_SEND < 2
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+#else
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+        __Pyx_pyiter_sendfunc am_send;
+    } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s))
+#endif
+#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0
+    #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21)
+#else
+    #define __Pyx_TPFLAGS_HAVE_AM_SEND (0)
+#endif
+#if PY_VERSION_HEX >= 0x03090000
+#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get()
+#else
+#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000
+#ifdef __cplusplus
+extern "C"
+#endif
+PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize);
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) {
+    int value;
+    PyObject *py_value = PyObject_GetAttrString(inspect, name);
+    if (!py_value) return 0;
+    value = (int) PyLong_AsLong(py_value);
+    Py_DECREF(py_value);
+    *write_to = value;
+    return value != -1 || !PyErr_Occurred();
+}
+static int __Pyx_init_co_variables(void) {
+    PyObject *inspect;
+    int result;
+    inspect = PyImport_ImportModule("inspect");
+    result =
+#if !defined(CO_OPTIMIZED)
+        __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) &&
+#endif
+#if !defined(CO_NEWLOCALS)
+        __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) &&
+#endif
+#if !defined(CO_VARARGS)
+        __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) &&
+#endif
+#if !defined(CO_VARKEYWORDS)
+        __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) &&
+#endif
+#if !defined(CO_ASYNC_GENERATOR)
+        __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) &&
+#endif
+#if !defined(CO_GENERATOR)
+        __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) &&
+#endif
+#if !defined(CO_COROUTINE)
+        __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) &&
+#endif
+        1;
+    Py_DECREF(inspect);
+    return result ? 0 : -1;
+}
+#else
+static int __Pyx_init_co_variables(void) {
+    return 0;  // It's a limited API-only feature
+}
+#endif
+
+/* MathInitCode */
+#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)
+  #ifndef _USE_MATH_DEFINES
+    #define _USE_MATH_DEFINES
+  #endif
+#endif
+#include <math.h>
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0
+#endif
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+#endif
+#if CYTHON_CLINE_IN_TRACEBACK
+#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; }
+#else
+#define __PYX_MARK_ERR_POS(f_index, lineno)  { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; }
+#endif
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }
+
+#ifdef CYTHON_EXTERN_C
+    #undef __PYX_EXTERN_C
+    #define __PYX_EXTERN_C CYTHON_EXTERN_C
+#elif defined(__PYX_EXTERN_C)
+    #ifdef _MSC_VER
+    #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.")
+    #else
+    #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.
+    #endif
+#else
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__cana__cboolean_node
+#define __PYX_HAVE_API__cana__cboolean_node
+/* Early includes */
+#include <string.h>
+#include <stdio.h>
+
+    #if PY_MAJOR_VERSION <= 2
+    #define PyDict_GetItemWithError _PyDict_GetItemWithError
+    #endif
+    
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
+    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s)
+#else
+    #define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AsString(s))
+    #define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AsString(s))
+    #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s)
+#endif
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef)
+    return Py_NewRef(obj);
+#else
+    Py_INCREF(obj);
+    return obj;
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef)
+    return Py_XNewRef(obj);
+#else
+    Py_XINCREF(obj);
+    return obj;
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b);
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t);
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x)
+#else
+#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x)
+#endif
+#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x))
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)\
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+  #else
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)\
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL)
+#else
+  #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+/* PretendToInitialize */
+#ifdef __cplusplus
+#if __cplusplus > 201103L
+#include <type_traits>
+#endif
+template <typename T>
+static void __Pyx_pretend_to_initialize(T* ptr) {
+#if __cplusplus > 201103L
+    if ((std::is_trivially_default_constructible<T>::value))
+#endif
+        *ptr = T();
+    (void)ptr;
+}
+#else
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+#endif
+
+
+#if !CYTHON_USE_MODULE_STATE
+static PyObject *__pyx_m = NULL;
+#endif
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * const __pyx_cfilenm = __FILE__;
+static const char *__pyx_filename;
+
+/* #### Code section: filename_table ### */
+
+static const char* const __pyx_f[] = {
+  "cana/cboolean_node.pyx",
+  "cpython/type.pxd",
+};
+/* #### Code section: utility_code_proto_before_types ### */
+/* Atomics.proto */
+#include <pythread.h>
+#ifndef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 1
+#endif
+#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS
+#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __pyx_atomic_int_type int
+#define __pyx_nonatomic_int_type int
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+                        (__STDC_VERSION__ >= 201112L) &&\
+                        !defined(__STDC_NO_ATOMICS__))
+    #include <stdatomic.h>
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+                    (__cplusplus >= 201103L) ||\
+                    (defined(_MSC_VER) && _MSC_VER >= 1700)))
+    #include <atomic>
+#endif
+#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\
+                        (__STDC_VERSION__ >= 201112L) &&\
+                        !defined(__STDC_NO_ATOMICS__) &&\
+                       ATOMIC_INT_LOCK_FREE == 2)
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type atomic_int
+    #define __pyx_atomic_ptr_type atomic_uintptr_t
+    #define __pyx_nonatomic_ptr_type uintptr_t
+    #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed)
+    #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel)
+    #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel)
+    #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg)
+    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired)
+    #define __pyx_atomic_load(value) atomic_load(value)
+    #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed)
+    #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire)
+    #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
+    #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired)
+    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+        #pragma message ("Using standard C atomics")
+    #elif defined(__PYX_DEBUG_ATOMICS)
+        #warning "Using standard C atomics"
+    #endif
+#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\
+                    (__cplusplus >= 201103L) ||\
+\
+                    (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\
+                    ATOMIC_INT_LOCK_FREE == 2)
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type std::atomic_int
+    #define __pyx_atomic_ptr_type std::atomic_uintptr_t
+    #define __pyx_nonatomic_ptr_type uintptr_t
+    #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed)
+    #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel)
+    #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel)
+    #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg)
+    #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired)
+    #define __pyx_atomic_load(value) std::atomic_load(value)
+    #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed)
+    #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire)
+    #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value)
+    #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired)
+    #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER)
+        #pragma message ("Using standard C++ atomics")
+    #elif defined(__PYX_DEBUG_ATOMICS)
+        #warning "Using standard C++ atomics"
+    #endif
+#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\
+                    (__GNUC_MINOR__ > 1 ||\
+                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2))))
+    #define __pyx_atomic_ptr_type void*
+    #define __pyx_nonatomic_ptr_type void*
+    #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1)
+    #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg)
+    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
+        __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0)
+    #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value)
+    static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) {
+        __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using GNU atomics"
+    #endif
+#elif CYTHON_ATOMICS && defined(_MSC_VER)
+    #include <intrin.h>
+    #undef __pyx_atomic_int_type
+    #define __pyx_atomic_int_type long
+    #define __pyx_atomic_ptr_type void*
+    #undef __pyx_nonatomic_int_type
+    #define __pyx_nonatomic_int_type long
+    #define __pyx_nonatomic_ptr_type void*
+    #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer)
+    #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1)
+    #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1)
+    #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1)
+    #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg)
+    static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) {
+        __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0)
+    #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value)
+    #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value
+    #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0)
+    #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value)
+    static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) {
+        __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected);
+        int result = old == *expected;
+        *expected = old;
+        return result;
+    }
+    #ifdef __PYX_DEBUG_ATOMICS
+        #pragma message ("Using MSVC atomics")
+    #endif
+#else
+    #undef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 0
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Not using atomics"
+    #endif
+#endif
+
+/* CriticalSectionsDefinition.proto */
+#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __Pyx_PyCriticalSection void*
+#define __Pyx_PyCriticalSection2 void*
+#define __Pyx_PyCriticalSection_End(cs)
+#define __Pyx_PyCriticalSection2_End(cs)
+#else
+#define __Pyx_PyCriticalSection PyCriticalSection
+#define __Pyx_PyCriticalSection2 PyCriticalSection2
+#define __Pyx_PyCriticalSection_End PyCriticalSection_End
+#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End
+#endif
+
+/* CriticalSections.proto */
+#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs)
+#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs)
+#else
+#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin
+#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin
+#endif
+#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_BEGIN_CRITICAL_SECTION(o) {
+#define __Pyx_END_CRITICAL_SECTION() }
+#else
+#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION
+#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION
+#endif
+
+/* IncludeStructmemberH.proto */
+#include <structmember.h>
+
+/* #### Code section: numeric_typedefs ### */
+/* #### Code section: complex_type_declarations ### */
+/* #### Code section: type_declarations ### */
+
+/*--- Type declarations ---*/
+/* #### Code section: utility_code_proto ### */
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, Py_ssize_t);
+    void (*DECREF)(void*, PyObject*, Py_ssize_t);
+    void (*GOTREF)(void*, PyObject*, Py_ssize_t);
+    void (*GIVEREF)(void*, PyObject*, Py_ssize_t);
+    void* (*SetupContext)(const char*, Py_ssize_t, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
+  #define __Pyx_RefNannyFinishContextNogil() {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __Pyx_RefNannyFinishContext();\
+              PyGILState_Release(__pyx_gilstate_save);\
+          }
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__))
+  #define __Pyx_XINCREF(r)  do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContextNogil()
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_Py_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; Py_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  (__pyx_tstate->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  (__pyx_tstate->curexc_type)
+#endif
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* IterFinish.proto */
+static CYTHON_INLINE int __Pyx_IterFinish(void);
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectFastCall.proto */
+#define __Pyx_PyObject_FastCall(func, args, nargs)  __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL)
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs);
+
+/* PyObjectCallNoArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* PyObjectGetMethod.proto */
+#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)))
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+#endif
+
+/* PyObjectCallMethod0.proto */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* UnpackItemEndCheck.proto */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* UnpackTupleError.proto */
+static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
+
+/* UnpackTuple2.proto */
+static CYTHON_INLINE int __Pyx_unpack_tuple2(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple);
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
+static int __Pyx_unpack_tuple2_generic(
+    PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple);
+
+/* dict_iter.proto */
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_is_dict);
+static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
+                                              PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
+
+/* RaiseUnexpectedTypeError.proto */
+static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj);
+
+/* FloatExceptionCheck.proto */
+#define __PYX_CHECK_FLOAT_EXCEPTION(value, error_value)\
+    ((error_value) == (error_value) ?\
+     (value) == (error_value) :\
+     (value) != (value))
+
+/* TupleAndListFromArray.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n);
+#endif
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* UnicodeEquals.proto */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* fastcall.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i)
+#elif CYTHON_ASSUME_SAFE_MACROS
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i))
+#else
+    #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i))
+#endif
+#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds)
+#define __Pyx_KwValues_VARARGS(args, nargs) NULL
+#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s)
+#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw)
+#if CYTHON_METH_FASTCALL
+    #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i])
+    #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds)
+    #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs))
+    static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s);
+  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues);
+  #else
+    #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw)
+  #endif
+#else
+    #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS
+    #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS
+    #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS
+    #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS
+    #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS
+#endif
+#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start)
+#else
+#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop)
+#endif
+
+/* py_dict_items.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d);
+
+/* CallCFunction.proto */
+#define __Pyx_CallCFunction(cfunc, self, args)\
+    ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args)
+#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\
+    ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs)
+#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\
+    ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs)
+#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\
+    ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames)
+
+/* UnpackUnboundCMethod.proto */
+typedef struct {
+    PyObject *type;
+    PyObject **method_name;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS
+    __pyx_atomic_int_type initialized;
+#endif
+    PyCFunction func;
+    PyObject *method;
+    int flag;
+} __Pyx_CachedCFunction;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) {
+#if !CYTHON_ATOMICS
+    return 1;
+#else
+    __pyx_nonatomic_int_type expected = 0;
+    if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) {
+        return 0;
+    }
+    return expected;
+#endif
+}
+static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) {
+#if CYTHON_ATOMICS
+    __pyx_atomic_store(&cfunc->initialized, 2);
+#endif
+}
+#else
+#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2
+#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc)
+#endif
+
+/* CallUnboundCMethod0.proto */
+CYTHON_UNUSED
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
+#else
+#define __Pyx_CallUnboundCMethod0(cfunc, self)  __Pyx__CallUnboundCMethod0(cfunc, self)
+#endif
+
+/* py_dict_values.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d);
+
+/* OwnedDictNext.proto */
+#if CYTHON_AVOID_BORROWED_REFS
+static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue);
+#else
+CYTHON_INLINE
+static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue);
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywordsImpl.export */
+static int __Pyx_ParseKeywordsTuple(
+    PyObject *kwds,
+    PyObject * const *kwvalues,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs
+);
+static int __Pyx_ParseKeywordDictToDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name
+);
+static int __Pyx_ParseKeywordDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs
+);
+
+/* CallUnboundCMethod2.proto */
+CYTHON_UNUSED
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2);
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2);
+#else
+#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2)  __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2)
+#endif
+
+/* ParseKeywords.proto */
+static CYTHON_INLINE int __Pyx_ParseKeywords(
+    PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[],
+    PyObject *kwds2, PyObject *values[],
+    Py_ssize_t num_pos_args, Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs
+);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* ArgTypeTestFunc.export */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+    ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+        __Pyx__ArgTypeTest(obj, type, name, exact))
+
+/* TypeImport.proto */
+#ifndef __PYX_HAVE_RT_ImportType_proto_3_2_0
+#define __PYX_HAVE_RT_ImportType_proto_3_2_0
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#include <stdalign.h>
+#endif
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L
+#define __PYX_GET_STRUCT_ALIGNMENT_3_2_0(s) alignof(s)
+#else
+#define __PYX_GET_STRUCT_ALIGNMENT_3_2_0(s) sizeof(void*)
+#endif
+enum __Pyx_ImportType_CheckSize_3_2_0 {
+   __Pyx_ImportType_CheckSize_Error_3_2_0 = 0,
+   __Pyx_ImportType_CheckSize_Warn_3_2_0 = 1,
+   __Pyx_ImportType_CheckSize_Ignore_3_2_0 = 2
+};
+static PyTypeObject *__Pyx_ImportType_3_2_0(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_0 check_size);
+#endif
+
+/* dict_setdefault.proto */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value);
+
+/* LimitedApiGetTypeDict.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp);
+#endif
+
+/* SetItemOnTypeDict.proto */
+static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v);
+#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v)
+
+/* FixUpExtensionType.proto */
+static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type);
+
+/* AddModuleRef.proto */
+#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\
+     __PYX_LIMITED_VERSION_HEX < 0x030d0000)
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name);
+#else
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#endif
+
+/* FetchSharedCythonModule.proto */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void);
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases);
+
+/* CommonTypesMetaclass.proto */
+static int __pyx_CommonTypesMetaclass_init(PyObject *module);
+#define __Pyx_CommonTypesMetaclass_USED
+
+/* CallTypeTraverse.proto */
+#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
+#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0
+#else
+static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg);
+#endif
+
+/* PyMethodNew.proto */
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ);
+
+/* PyVectorcallFastCallDict.proto */
+#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw);
+#endif
+
+/* CythonFunctionShared.proto */
+#define __Pyx_CyFunction_USED
+#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
+#define __Pyx_CYFUNCTION_CCLASS        0x04
+#define __Pyx_CYFUNCTION_COROUTINE     0x08
+#define __Pyx_CyFunction_GetClosure(f)\
+    (((__pyx_CyFunctionObject *) (f))->func_closure)
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#else
+  #define __Pyx_CyFunction_GetClassObj(f)\
+      ((PyObject*) ((PyCMethodObject *) (f))->mm_class)
+#endif
+#define __Pyx_CyFunction_SetClassObj(f, classobj)\
+    __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj))
+#define __Pyx_CyFunction_Defaults(type, f)\
+    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject_HEAD
+    PyObject *func;
+#elif PY_VERSION_HEX < 0x030900B1
+    PyCFunctionObject func;
+#else
+    PyCMethodObject func;
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL
+    __pyx_vectorcallfunc func_vectorcall;
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_weakreflist;
+#endif
+#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_dict;
+#endif
+    PyObject *func_name;
+    PyObject *func_qualname;
+    PyObject *func_doc;
+    PyObject *func_globals;
+    PyObject *func_code;
+    PyObject *func_closure;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *func_classobj;
+#endif
+    PyObject *defaults;
+    int flags;
+    PyObject *defaults_tuple;
+    PyObject *defaults_kwdict;
+    PyObject *(*defaults_getter)(PyObject *);
+    PyObject *func_annotations;
+    PyObject *func_is_coroutine;
+} __pyx_CyFunctionObject;
+#undef __Pyx_CyOrPyCFunction_Check
+#define __Pyx_CyFunction_Check(obj)  __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType)
+#define __Pyx_CyOrPyCFunction_Check(obj)  __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type)
+#define __Pyx_CyFunction_CheckExact(obj)  __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType)
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void));
+#undef __Pyx_IsSameCFunction
+#define __Pyx_IsSameCFunction(func, cfunc)   __Pyx__IsSameCyOrCFunction(func, cfunc)
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj);
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func,
+                                                         PyTypeObject *defaults_type);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+                                                            PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+                                                             PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+                                                              PyObject *dict);
+static int __pyx_CyFunction_init(PyObject *module);
+#if CYTHON_METH_FASTCALL
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+#if CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall)
+#else
+#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall)
+#endif
+#endif
+
+/* CythonFunction.proto */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml,
+                                      int flags, PyObject* qualname,
+                                      PyObject *closure,
+                                      PyObject *module, PyObject *globals,
+                                      PyObject* code);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT  ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict)  (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+    (version_var) = __PYX_GET_DICT_VERSION(dict);\
+    (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+    static PY_UINT64_T __pyx_dict_version = 0;\
+    static PyObject *__pyx_dict_cached_value = NULL;\
+    if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+        (VAR) = __Pyx_XNewRef(__pyx_dict_cached_value);\
+    } else {\
+        (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+        __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+    }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict)  (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP)  (VAR) = (LOOKUP);
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* PyObjectGetAttrStrNoError.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name);
+
+/* CLineInTraceback.proto */
+#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#else
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#endif
+
+/* CodeObjectCache.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject __Pyx_CachedCodeObjectType;
+#else
+typedef PyCodeObject __Pyx_CachedCodeObjectType;
+#endif
+typedef struct {
+    __Pyx_CachedCodeObjectType* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_int_type accessor_count;
+  #endif
+};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* GCCDiagnostics.proto */
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *);
+
+/* FormatTypeName.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+typedef PyObject *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%U"
+#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj)
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
+#else
+static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp);
+#endif
+#else  // !LIMITED_API
+typedef const char *__Pyx_TypeName;
+#define __Pyx_FMT_TYPENAME "%.200s"
+#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name)
+#define __Pyx_DECREF_TypeName(obj)
+#endif
+
+/* PyObjectVectorCallKwBuilder.proto */
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+#if CYTHON_VECTORCALL
+#if PY_VERSION_HEX >= 0x03090000
+#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall
+#else
+#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall
+#endif
+#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n)
+static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n);
+#else
+#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict
+#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n)
+#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value)
+#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value)
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *);
+
+/* FastTypeChecks.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2)
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
+#else
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2))
+#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) {
+    return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2);
+}
+#endif
+#define __Pyx_PyErr_ExceptionMatches2(err1, err2)  __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#ifdef PyExceptionInstance_Check
+  #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj)
+#else
+  #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException)
+#endif
+
+/* GetRuntimeVersion.proto */
+#if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+static unsigned long __Pyx_cached_runtime_version = 0;
+static void __Pyx_init_runtime_version(void);
+#else
+#define __Pyx_init_runtime_version()
+#endif
+static unsigned long __Pyx_get_runtime_version(void);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer);
+
+/* DecompressString.proto */
+static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo);
+
+/* MultiPhaseInitModuleState.proto */
+#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
+static PyObject *__Pyx_State_FindModule(void*);
+static int __Pyx_State_AddModule(PyObject* module, void*);
+static int __Pyx_State_RemoveModule(void*);
+#elif CYTHON_USE_MODULE_STATE
+#define __Pyx_State_FindModule PyState_FindModule
+#define __Pyx_State_AddModule PyState_AddModule
+#define __Pyx_State_RemoveModule PyState_RemoveModule
+#endif
+
+/* #### Code section: module_declarations ### */
+/* CythonABIVersion.proto */
+#if CYTHON_COMPILING_IN_LIMITED_API
+    #if CYTHON_METH_FASTCALL
+        #define __PYX_FASTCALL_ABI_SUFFIX  "_fastcall"
+    #else
+        #define __PYX_FASTCALL_ABI_SUFFIX
+    #endif
+    #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
+#else
+    #define __PYX_LIMITED_ABI_SUFFIX
+#endif
+#if __PYX_HAS_PY_AM_SEND == 1
+    #define __PYX_AM_SEND_ABI_SUFFIX
+#elif __PYX_HAS_PY_AM_SEND == 2
+    #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport"
+#else
+    #define __PYX_AM_SEND_ABI_SUFFIX "noamsend"
+#endif
+#ifndef __PYX_MONITORING_ABI_SUFFIX
+    #define __PYX_MONITORING_ABI_SUFFIX
+#endif
+#if CYTHON_USE_TP_FINALIZE
+    #define __PYX_TP_FINALIZE_ABI_SUFFIX
+#else
+    #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize"
+#endif
+#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED)
+    #define __PYX_FREELISTS_ABI_SUFFIX
+#else
+    #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists"
+#endif
+#define CYTHON_ABI  __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX
+#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
+#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
+
+
+/* Module declarations from "cython" */
+
+/* Module declarations from "libc.string" */
+
+/* Module declarations from "libc.stdio" */
+
+/* Module declarations from "__builtin__" */
+
+/* Module declarations from "cpython.type" */
+
+/* Module declarations from "cpython" */
+
+/* Module declarations from "cpython.object" */
+
+/* Module declarations from "cpython.pyport" */
+
+/* Module declarations from "cpython.dict" */
+
+/* Module declarations from "cpython.list" */
+
+/* Module declarations from "cpython.tuple" */
+
+/* Module declarations from "cpython.sequence" */
+
+/* Module declarations from "cpython.exc" */
+
+/* Module declarations from "cana.cboolean_node" */
+static CYTHON_INLINE Py_ssize_t __pyx_f_4cana_13cboolean_node__safe_sequence_size(PyObject *); /*proto*/
+static CYTHON_INLINE double __pyx_f_4cana_13cboolean_node__sum_group_lengths(PyObject *); /*proto*/
+static double __pyx_f_4cana_13cboolean_node_input_symmetry_mean_fast(PyObject *, int, int __pyx_skip_dispatch); /*proto*/
+static double __pyx_f_4cana_13cboolean_node_input_symmetry_mean_annigen_fast(PyObject *, int __pyx_skip_dispatch); /*proto*/
+/* #### Code section: typeinfo ### */
+/* #### Code section: before_global_var ### */
+#define __Pyx_MODULE_NAME "cana.cboolean_node"
+extern int __pyx_module_is_main_cana__cboolean_node;
+int __pyx_module_is_main_cana__cboolean_node = 0;
+
+/* Implementation of "cana.cboolean_node" */
+/* #### Code section: global_var ### */
+/* #### Code section: string_decls ### */
+static const char __pyx_k_Cython_accelerated_helpers_for_c[] = "Cython-accelerated helpers for ``cana.boolean_node``.";
+/* #### Code section: decls ### */
+static PyObject *__pyx_pf_4cana_13cboolean_node_input_symmetry_mean_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ts_coverage, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_4cana_13cboolean_node_2input_symmetry_mean_annigen_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ts_coverage); /* proto */
+/* #### Code section: late_includes ### */
+/* #### Code section: module_state ### */
+/* SmallCodeConfig */
+#ifndef CYTHON_SMALL_CODE
+#if defined(__clang__)
+    #define CYTHON_SMALL_CODE
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+    #define CYTHON_SMALL_CODE __attribute__((cold))
+#else
+    #define CYTHON_SMALL_CODE
+#endif
+#endif
+
+typedef struct {
+  PyObject *__pyx_d;
+  PyObject *__pyx_b;
+  PyObject *__pyx_cython_runtime;
+  PyObject *__pyx_empty_tuple;
+  PyObject *__pyx_empty_bytes;
+  PyObject *__pyx_empty_unicode;
+  PyTypeObject *__pyx_ptype_7cpython_4type_type;
+  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items;
+  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop;
+  __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values;
+  PyObject *__pyx_codeobj_tab[2];
+  PyObject *__pyx_string_tab[26];
+/* #### Code section: module_state_contents ### */
+/* CommonTypesMetaclass.module_state_decls */
+PyTypeObject *__pyx_CommonTypesMetaclassType;
+
+/* CachedMethodType.module_state_decls */
+#if CYTHON_COMPILING_IN_LIMITED_API
+PyObject *__Pyx_CachedMethodType;
+#endif
+
+/* CythonFunctionShared.module_state_decls */
+PyTypeObject *__pyx_CyFunctionType;
+
+/* CodeObjectCache.module_state_decls */
+struct __Pyx_CodeObjectCache __pyx_code_cache;
+
+/* #### Code section: module_state_end ### */
+} __pyx_mstatetype;
+
+#if CYTHON_USE_MODULE_STATE
+#ifdef __cplusplus
+namespace {
+extern struct PyModuleDef __pyx_moduledef;
+} /* anonymous namespace */
+#else
+static struct PyModuleDef __pyx_moduledef;
+#endif
+
+#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef)))
+
+#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef))
+#else
+static __pyx_mstatetype __pyx_mstate_global_static =
+#ifdef __cplusplus
+    {};
+#else
+    {0};
+#endif
+static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static;
+#endif
+/* #### Code section: constant_name_defines ### */
+#define __pyx_kp_u_ __pyx_string_tab[0]
+#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[1]
+#define __pyx_kp_u_add_note __pyx_string_tab[2]
+#define __pyx_kp_u_cana_cboolean_node_pyx __pyx_string_tab[3]
+#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[4]
+#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[5]
+#define __pyx_n_u_cana_cboolean_node __pyx_string_tab[6]
+#define __pyx_n_u_cline_in_traceback __pyx_string_tab[7]
+#define __pyx_n_u_func __pyx_string_tab[8]
+#define __pyx_n_u_input_symmetry_mean_annigen_fast __pyx_string_tab[9]
+#define __pyx_n_u_input_symmetry_mean_fast __pyx_string_tab[10]
+#define __pyx_n_u_is_coroutine __pyx_string_tab[11]
+#define __pyx_n_u_items __pyx_string_tab[12]
+#define __pyx_n_u_k __pyx_string_tab[13]
+#define __pyx_n_u_main __pyx_string_tab[14]
+#define __pyx_n_u_module __pyx_string_tab[15]
+#define __pyx_n_u_name __pyx_string_tab[16]
+#define __pyx_n_u_pop __pyx_string_tab[17]
+#define __pyx_n_u_qualname __pyx_string_tab[18]
+#define __pyx_n_u_set_name __pyx_string_tab[19]
+#define __pyx_n_u_setdefault __pyx_string_tab[20]
+#define __pyx_n_u_test __pyx_string_tab[21]
+#define __pyx_n_u_ts_coverage __pyx_string_tab[22]
+#define __pyx_n_u_values __pyx_string_tab[23]
+#define __pyx_kp_b_iso88591_A_3a_q_1_q_r_A_q_t3b_1_gQ_4q_4 __pyx_string_tab[24]
+#define __pyx_kp_b_iso88591_A_Q_3a_q_1_q_gQ_4q_4_1A_d_1_oQa __pyx_string_tab[25]
+/* #### Code section: module_state_clear ### */
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) {
+  __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m);
+  if (!clear_module_state) return 0;
+  Py_CLEAR(clear_module_state->__pyx_d);
+  Py_CLEAR(clear_module_state->__pyx_b);
+  Py_CLEAR(clear_module_state->__pyx_cython_runtime);
+  Py_CLEAR(clear_module_state->__pyx_empty_tuple);
+  Py_CLEAR(clear_module_state->__pyx_empty_bytes);
+  Py_CLEAR(clear_module_state->__pyx_empty_unicode);
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __Pyx_State_RemoveModule(NULL);
+  #endif
+  Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type);
+  for (int i=0; i<2; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); }
+  for (int i=0; i<26; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); }
+/* #### Code section: module_state_clear_contents ### */
+/* CommonTypesMetaclass.module_state_clear */
+Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType);
+
+/* CythonFunctionShared.module_state_clear */
+Py_CLEAR(clear_module_state->__pyx_CyFunctionType);
+
+/* #### Code section: module_state_clear_end ### */
+return 0;
+}
+#endif
+/* #### Code section: module_state_traverse ### */
+#if CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
+  __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m);
+  if (!traverse_module_state) return 0;
+  Py_VISIT(traverse_module_state->__pyx_d);
+  Py_VISIT(traverse_module_state->__pyx_b);
+  Py_VISIT(traverse_module_state->__pyx_cython_runtime);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes);
+  __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode);
+  Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type);
+  for (int i=0; i<2; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); }
+  for (int i=0; i<26; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); }
+/* #### Code section: module_state_traverse_contents ### */
+/* CommonTypesMetaclass.module_state_traverse */
+Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType);
+
+/* CythonFunctionShared.module_state_traverse */
+Py_VISIT(traverse_module_state->__pyx_CyFunctionType);
+
+/* #### Code section: module_state_traverse_end ### */
+return 0;
+}
+#endif
+/* #### Code section: module_code ### */
+
+/* "cana/cboolean_node.pyx":17
+ * 
+ * 
+ * @cython.cfunc             # <<<<<<<<<<<<<<
+ * cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+ *     cdef Py_ssize_t size = PySequence_Size(obj)
+*/
+
+static CYTHON_INLINE Py_ssize_t __pyx_f_4cana_13cboolean_node__safe_sequence_size(PyObject *__pyx_v_obj) {
+  Py_ssize_t __pyx_v_size;
+  Py_ssize_t __pyx_r;
+  Py_ssize_t __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* "cana/cboolean_node.pyx":19
+ * @cython.cfunc
+ * cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+ *     cdef Py_ssize_t size = PySequence_Size(obj)             # <<<<<<<<<<<<<<
+ *     if size < 0:
+ *         PyErr_Clear()
+*/
+  __pyx_t_1 = PySequence_Size(__pyx_v_obj); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1L))) __PYX_ERR(0, 19, __pyx_L1_error)
+  __pyx_v_size = __pyx_t_1;
+
+  /* "cana/cboolean_node.pyx":20
+ * cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+ *     cdef Py_ssize_t size = PySequence_Size(obj)
+ *     if size < 0:             # <<<<<<<<<<<<<<
+ *         PyErr_Clear()
+ *         return 0
+*/
+  __pyx_t_2 = (__pyx_v_size < 0);
+  if (__pyx_t_2) {
+
+    /* "cana/cboolean_node.pyx":21
+ *     cdef Py_ssize_t size = PySequence_Size(obj)
+ *     if size < 0:
+ *         PyErr_Clear()             # <<<<<<<<<<<<<<
+ *         return 0
+ *     return size
+*/
+    PyErr_Clear();
+
+    /* "cana/cboolean_node.pyx":22
+ *     if size < 0:
+ *         PyErr_Clear()
+ *         return 0             # <<<<<<<<<<<<<<
+ *     return size
+ * 
+*/
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":20
+ * cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+ *     cdef Py_ssize_t size = PySequence_Size(obj)
+ *     if size < 0:             # <<<<<<<<<<<<<<
+ *         PyErr_Clear()
+ *         return 0
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":23
+ *         PyErr_Clear()
+ *         return 0
+ *     return size             # <<<<<<<<<<<<<<
+ * 
+ * 
+*/
+  __pyx_r = __pyx_v_size;
+  goto __pyx_L0;
+
+  /* "cana/cboolean_node.pyx":17
+ * 
+ * 
+ * @cython.cfunc             # <<<<<<<<<<<<<<
+ * cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+ *     cdef Py_ssize_t size = PySequence_Size(obj)
+*/
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("cana.cboolean_node._safe_sequence_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1L;
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "cana/cboolean_node.pyx":26
+ * 
+ * 
+ * @cython.cfunc             # <<<<<<<<<<<<<<
+ * cdef inline double _sum_group_lengths(list f_theta) except? -1.0:
+ *     cdef Py_ssize_t len_f_theta = PyList_GET_SIZE(f_theta)
+*/
+
+static CYTHON_INLINE double __pyx_f_4cana_13cboolean_node__sum_group_lengths(PyObject *__pyx_v_f_theta) {
+  Py_ssize_t __pyx_v_len_f_theta;
+  Py_ssize_t __pyx_v_i;
+  Py_ssize_t __pyx_v_j;
+  Py_ssize_t __pyx_v_group_len;
+  double __pyx_v_total;
+  PyObject *__pyx_v_ts_obj = 0;
+  PyObject *__pyx_v_groups_obj = 0;
+  PyObject *__pyx_v_group_obj = 0;
+  PyObject *__pyx_v_ts = 0;
+  PyObject *__pyx_v_groups = 0;
+  double __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  PyObject *__pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  Py_ssize_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("_sum_group_lengths", 0);
+
+  /* "cana/cboolean_node.pyx":28
+ * @cython.cfunc
+ * cdef inline double _sum_group_lengths(list f_theta) except? -1.0:
+ *     cdef Py_ssize_t len_f_theta = PyList_GET_SIZE(f_theta)             # <<<<<<<<<<<<<<
+ *     cdef Py_ssize_t i
+ *     cdef Py_ssize_t j
+*/
+  __pyx_v_len_f_theta = PyList_GET_SIZE(__pyx_v_f_theta);
+
+  /* "cana/cboolean_node.pyx":32
+ *     cdef Py_ssize_t j
+ *     cdef Py_ssize_t group_len
+ *     cdef double total = 0.0             # <<<<<<<<<<<<<<
+ *     cdef object ts_obj
+ *     cdef object groups_obj
+*/
+  __pyx_v_total = 0.0;
+
+  /* "cana/cboolean_node.pyx":39
+ *     cdef list groups
+ * 
+ *     if len_f_theta <= 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  __pyx_t_1 = (__pyx_v_len_f_theta <= 0);
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":40
+ * 
+ *     if len_f_theta <= 0:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ * 
+ *     for i in range(len_f_theta):
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":39
+ *     cdef list groups
+ * 
+ *     if len_f_theta <= 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":42
+ *         return 0.0
+ * 
+ *     for i in range(len_f_theta):             # <<<<<<<<<<<<<<
+ *         ts_obj = <object>PyList_GET_ITEM(f_theta, i)
+ *         if PyTuple_Check(ts_obj):
+*/
+  __pyx_t_2 = __pyx_v_len_f_theta;
+  __pyx_t_3 = __pyx_t_2;
+  for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) {
+    __pyx_v_i = __pyx_t_4;
+
+    /* "cana/cboolean_node.pyx":43
+ * 
+ *     for i in range(len_f_theta):
+ *         ts_obj = <object>PyList_GET_ITEM(f_theta, i)             # <<<<<<<<<<<<<<
+ *         if PyTuple_Check(ts_obj):
+ *             ts = <tuple>ts_obj
+*/
+    __pyx_t_5 = PyList_GET_ITEM(__pyx_v_f_theta, __pyx_v_i);
+    __pyx_t_6 = ((PyObject *)__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_XDECREF_SET(__pyx_v_ts_obj, __pyx_t_6);
+    __pyx_t_6 = 0;
+
+    /* "cana/cboolean_node.pyx":44
+ *     for i in range(len_f_theta):
+ *         ts_obj = <object>PyList_GET_ITEM(f_theta, i)
+ *         if PyTuple_Check(ts_obj):             # <<<<<<<<<<<<<<
+ *             ts = <tuple>ts_obj
+ *         else:
+*/
+    __pyx_t_1 = PyTuple_Check(__pyx_v_ts_obj);
+    if (__pyx_t_1) {
+
+      /* "cana/cboolean_node.pyx":45
+ *         ts_obj = <object>PyList_GET_ITEM(f_theta, i)
+ *         if PyTuple_Check(ts_obj):
+ *             ts = <tuple>ts_obj             # <<<<<<<<<<<<<<
+ *         else:
+ *             ts = tuple(ts_obj)
+*/
+      __pyx_t_6 = __pyx_v_ts_obj;
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_ts, ((PyObject*)__pyx_t_6));
+      __pyx_t_6 = 0;
+
+      /* "cana/cboolean_node.pyx":44
+ *     for i in range(len_f_theta):
+ *         ts_obj = <object>PyList_GET_ITEM(f_theta, i)
+ *         if PyTuple_Check(ts_obj):             # <<<<<<<<<<<<<<
+ *             ts = <tuple>ts_obj
+ *         else:
+*/
+      goto __pyx_L6;
+    }
+
+    /* "cana/cboolean_node.pyx":47
+ *             ts = <tuple>ts_obj
+ *         else:
+ *             ts = tuple(ts_obj)             # <<<<<<<<<<<<<<
+ *         groups_obj = <object>PyTuple_GET_ITEM(ts, 1)
+ *         if groups_obj is None or not groups_obj:
+*/
+    /*else*/ {
+      __pyx_t_6 = __Pyx_PySequence_Tuple(__pyx_v_ts_obj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 47, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_ts, ((PyObject*)__pyx_t_6));
+      __pyx_t_6 = 0;
+    }
+    __pyx_L6:;
+
+    /* "cana/cboolean_node.pyx":48
+ *         else:
+ *             ts = tuple(ts_obj)
+ *         groups_obj = <object>PyTuple_GET_ITEM(ts, 1)             # <<<<<<<<<<<<<<
+ *         if groups_obj is None or not groups_obj:
+ *             continue
+*/
+    __pyx_t_5 = PyTuple_GET_ITEM(__pyx_v_ts, 1);
+    __pyx_t_6 = ((PyObject *)__pyx_t_5);
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_XDECREF_SET(__pyx_v_groups_obj, __pyx_t_6);
+    __pyx_t_6 = 0;
+
+    /* "cana/cboolean_node.pyx":49
+ *             ts = tuple(ts_obj)
+ *         groups_obj = <object>PyTuple_GET_ITEM(ts, 1)
+ *         if groups_obj is None or not groups_obj:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(groups_obj):
+*/
+    __pyx_t_7 = (__pyx_v_groups_obj == Py_None);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_1 = __pyx_t_7;
+      goto __pyx_L8_bool_binop_done;
+    }
+    __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_groups_obj); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 49, __pyx_L1_error)
+    __pyx_t_8 = (!__pyx_t_7);
+    __pyx_t_1 = __pyx_t_8;
+    __pyx_L8_bool_binop_done:;
+    if (__pyx_t_1) {
+
+      /* "cana/cboolean_node.pyx":50
+ *         groups_obj = <object>PyTuple_GET_ITEM(ts, 1)
+ *         if groups_obj is None or not groups_obj:
+ *             continue             # <<<<<<<<<<<<<<
+ *         if not PyList_Check(groups_obj):
+ *             groups_obj = list(groups_obj)
+*/
+      goto __pyx_L4_continue;
+
+      /* "cana/cboolean_node.pyx":49
+ *             ts = tuple(ts_obj)
+ *         groups_obj = <object>PyTuple_GET_ITEM(ts, 1)
+ *         if groups_obj is None or not groups_obj:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(groups_obj):
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":51
+ *         if groups_obj is None or not groups_obj:
+ *             continue
+ *         if not PyList_Check(groups_obj):             # <<<<<<<<<<<<<<
+ *             groups_obj = list(groups_obj)
+ *         groups = <list>groups_obj
+*/
+    __pyx_t_1 = (!PyList_Check(__pyx_v_groups_obj));
+    if (__pyx_t_1) {
+
+      /* "cana/cboolean_node.pyx":52
+ *             continue
+ *         if not PyList_Check(groups_obj):
+ *             groups_obj = list(groups_obj)             # <<<<<<<<<<<<<<
+ *         groups = <list>groups_obj
+ *         for j in range(PyList_GET_SIZE(groups)):
+*/
+      __pyx_t_6 = PySequence_List(__pyx_v_groups_obj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 52, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF_SET(__pyx_v_groups_obj, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "cana/cboolean_node.pyx":51
+ *         if groups_obj is None or not groups_obj:
+ *             continue
+ *         if not PyList_Check(groups_obj):             # <<<<<<<<<<<<<<
+ *             groups_obj = list(groups_obj)
+ *         groups = <list>groups_obj
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":53
+ *         if not PyList_Check(groups_obj):
+ *             groups_obj = list(groups_obj)
+ *         groups = <list>groups_obj             # <<<<<<<<<<<<<<
+ *         for j in range(PyList_GET_SIZE(groups)):
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)
+*/
+    __pyx_t_6 = __pyx_v_groups_obj;
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_XDECREF_SET(__pyx_v_groups, ((PyObject*)__pyx_t_6));
+    __pyx_t_6 = 0;
+
+    /* "cana/cboolean_node.pyx":54
+ *             groups_obj = list(groups_obj)
+ *         groups = <list>groups_obj
+ *         for j in range(PyList_GET_SIZE(groups)):             # <<<<<<<<<<<<<<
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)
+ *             if PyList_Check(group_obj):
+*/
+    __pyx_t_9 = PyList_GET_SIZE(__pyx_v_groups);
+    __pyx_t_10 = __pyx_t_9;
+    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
+      __pyx_v_j = __pyx_t_11;
+
+      /* "cana/cboolean_node.pyx":55
+ *         groups = <list>groups_obj
+ *         for j in range(PyList_GET_SIZE(groups)):
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)             # <<<<<<<<<<<<<<
+ *             if PyList_Check(group_obj):
+ *                 group_len = PyList_GET_SIZE(group_obj)
+*/
+      __pyx_t_5 = PyList_GET_ITEM(__pyx_v_groups, __pyx_v_j);
+      __pyx_t_6 = ((PyObject *)__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_XDECREF_SET(__pyx_v_group_obj, __pyx_t_6);
+      __pyx_t_6 = 0;
+
+      /* "cana/cboolean_node.pyx":56
+ *         for j in range(PyList_GET_SIZE(groups)):
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)
+ *             if PyList_Check(group_obj):             # <<<<<<<<<<<<<<
+ *                 group_len = PyList_GET_SIZE(group_obj)
+ *             else:
+*/
+      __pyx_t_1 = PyList_Check(__pyx_v_group_obj);
+      if (__pyx_t_1) {
+
+        /* "cana/cboolean_node.pyx":57
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)
+ *             if PyList_Check(group_obj):
+ *                 group_len = PyList_GET_SIZE(group_obj)             # <<<<<<<<<<<<<<
+ *             else:
+ *                 group_len = _safe_sequence_size(group_obj)
+*/
+        __pyx_v_group_len = PyList_GET_SIZE(__pyx_v_group_obj);
+
+        /* "cana/cboolean_node.pyx":56
+ *         for j in range(PyList_GET_SIZE(groups)):
+ *             group_obj = <object>PyList_GET_ITEM(groups, j)
+ *             if PyList_Check(group_obj):             # <<<<<<<<<<<<<<
+ *                 group_len = PyList_GET_SIZE(group_obj)
+ *             else:
+*/
+        goto __pyx_L13;
+      }
+
+      /* "cana/cboolean_node.pyx":59
+ *                 group_len = PyList_GET_SIZE(group_obj)
+ *             else:
+ *                 group_len = _safe_sequence_size(group_obj)             # <<<<<<<<<<<<<<
+ *             total += group_len
+ * 
+*/
+      /*else*/ {
+        __pyx_t_12 = __pyx_f_4cana_13cboolean_node__safe_sequence_size(__pyx_v_group_obj); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1L))) __PYX_ERR(0, 59, __pyx_L1_error)
+        __pyx_v_group_len = __pyx_t_12;
+      }
+      __pyx_L13:;
+
+      /* "cana/cboolean_node.pyx":60
+ *             else:
+ *                 group_len = _safe_sequence_size(group_obj)
+ *             total += group_len             # <<<<<<<<<<<<<<
+ * 
+ *     return total
+*/
+      __pyx_v_total = (__pyx_v_total + __pyx_v_group_len);
+    }
+    __pyx_L4_continue:;
+  }
+
+  /* "cana/cboolean_node.pyx":62
+ *             total += group_len
+ * 
+ *     return total             # <<<<<<<<<<<<<<
+ * 
+ * 
+*/
+  __pyx_r = __pyx_v_total;
+  goto __pyx_L0;
+
+  /* "cana/cboolean_node.pyx":26
+ * 
+ * 
+ * @cython.cfunc             # <<<<<<<<<<<<<<
+ * cdef inline double _sum_group_lengths(list f_theta) except? -1.0:
+ *     cdef Py_ssize_t len_f_theta = PyList_GET_SIZE(f_theta)
+*/
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("cana.cboolean_node._sum_group_lengths", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = (-1.0);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_ts_obj);
+  __Pyx_XDECREF(__pyx_v_groups_obj);
+  __Pyx_XDECREF(__pyx_v_group_obj);
+  __Pyx_XDECREF(__pyx_v_ts);
+  __Pyx_XDECREF(__pyx_v_groups);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/cboolean_node.pyx":65
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+
+static PyObject *__pyx_pw_4cana_13cboolean_node_1input_symmetry_mean_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static double __pyx_f_4cana_13cboolean_node_input_symmetry_mean_fast(PyObject *__pyx_v_ts_coverage, int __pyx_v_k, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  double __pyx_v_numerator;
+  double __pyx_v_inv_total_states;
+  double __pyx_v_inv_len;
+  Py_ssize_t __pyx_v_len_f_theta;
+  PyObject *__pyx_v_f_theta = 0;
+  double __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  long __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  Py_ssize_t __pyx_t_5;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  int __pyx_t_8;
+  int __pyx_t_9;
+  double __pyx_t_10;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("input_symmetry_mean_fast", 0);
+
+  /* "cana/cboolean_node.pyx":83
+ *         Mean number of permutable inputs over the LUT entries.
+ *     """
+ *     cdef double numerator = 0.0             # <<<<<<<<<<<<<<
+ *     cdef double inv_total_states
+ *     cdef double inv_len
+*/
+  __pyx_v_numerator = 0.0;
+
+  /* "cana/cboolean_node.pyx":89
+ *     cdef list f_theta
+ * 
+ *     if ts_coverage is None:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+*/
+  __pyx_t_1 = (__pyx_v_ts_coverage == ((PyObject*)Py_None));
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":90
+ * 
+ *     if ts_coverage is None:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":89
+ *     cdef list f_theta
+ * 
+ *     if ts_coverage is None:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":91
+ *     if ts_coverage is None:
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if k <= 0:
+*/
+  __pyx_t_2 = PyDict_Size(__pyx_v_ts_coverage); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1L))) __PYX_ERR(0, 91, __pyx_L1_error)
+  __pyx_t_1 = (__pyx_t_2 == 0);
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":92
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ *     if k <= 0:
+ *         return 0.0
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":91
+ *     if ts_coverage is None:
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if k <= 0:
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":93
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0
+ *     if k <= 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  __pyx_t_1 = (__pyx_v_k <= 0);
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":94
+ *         return 0.0
+ *     if k <= 0:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ * 
+ *     inv_total_states = 1.0 / (1 << k)
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":93
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0
+ *     if k <= 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":96
+ *         return 0.0
+ * 
+ *     inv_total_states = 1.0 / (1 << k)             # <<<<<<<<<<<<<<
+ * 
+ *     for f_theta in ts_coverage.values():
+*/
+  __pyx_t_3 = (1 << __pyx_v_k);
+  if (unlikely(__pyx_t_3 == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 96, __pyx_L1_error)
+  }
+  __pyx_v_inv_total_states = (1.0 / ((double)__pyx_t_3));
+
+  /* "cana/cboolean_node.pyx":98
+ *     inv_total_states = 1.0 / (1 << k)
+ * 
+ *     for f_theta in ts_coverage.values():             # <<<<<<<<<<<<<<
+ *         if not f_theta:
+ *             continue
+*/
+  __pyx_t_2 = 0;
+  if (unlikely(__pyx_v_ts_coverage == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
+    __PYX_ERR(0, 98, __pyx_L1_error)
+  }
+  __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_ts_coverage, 1, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_5), (&__pyx_t_6)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_4);
+  __pyx_t_4 = __pyx_t_7;
+  __pyx_t_7 = 0;
+  while (1) {
+    __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_5, &__pyx_t_2, NULL, &__pyx_t_7, NULL, __pyx_t_6);
+    if (unlikely(__pyx_t_8 == 0)) break;
+    if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 98, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (!(likely(PyList_CheckExact(__pyx_t_7))||((__pyx_t_7) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_7))) __PYX_ERR(0, 98, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_7));
+    __pyx_t_7 = 0;
+
+    /* "cana/cboolean_node.pyx":99
+ * 
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(f_theta):
+*/
+    if (__pyx_v_f_theta == Py_None) __pyx_t_1 = 0;
+    else
+    {
+      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_f_theta);
+      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 99, __pyx_L1_error)
+      __pyx_t_1 = (__pyx_temp != 0);
+    }
+
+    __pyx_t_9 = (!__pyx_t_1);
+    if (__pyx_t_9) {
+
+      /* "cana/cboolean_node.pyx":100
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:
+ *             continue             # <<<<<<<<<<<<<<
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)
+*/
+      goto __pyx_L6_continue;
+
+      /* "cana/cboolean_node.pyx":99
+ * 
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(f_theta):
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":101
+ *         if not f_theta:
+ *             continue
+ *         if not PyList_Check(f_theta):             # <<<<<<<<<<<<<<
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+*/
+    __pyx_t_9 = (!PyList_Check(__pyx_v_f_theta));
+    if (__pyx_t_9) {
+
+      /* "cana/cboolean_node.pyx":102
+ *             continue
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)             # <<<<<<<<<<<<<<
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+*/
+      __pyx_t_7 = PySequence_List(__pyx_v_f_theta); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_7));
+      __pyx_t_7 = 0;
+
+      /* "cana/cboolean_node.pyx":101
+ *         if not f_theta:
+ *             continue
+ *         if not PyList_Check(f_theta):             # <<<<<<<<<<<<<<
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":103
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta             # <<<<<<<<<<<<<<
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:
+*/
+    __pyx_t_7 = __pyx_v_f_theta;
+    __Pyx_INCREF(__pyx_t_7);
+    __Pyx_DECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_7));
+    __pyx_t_7 = 0;
+
+    /* "cana/cboolean_node.pyx":104
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)             # <<<<<<<<<<<<<<
+ *         if len_f_theta == 0:
+ *             continue
+*/
+    __pyx_v_len_f_theta = PyList_GET_SIZE(__pyx_v_f_theta);
+
+    /* "cana/cboolean_node.pyx":105
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:             # <<<<<<<<<<<<<<
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+*/
+    __pyx_t_9 = (__pyx_v_len_f_theta == 0);
+    if (__pyx_t_9) {
+
+      /* "cana/cboolean_node.pyx":106
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:
+ *             continue             # <<<<<<<<<<<<<<
+ *         inv_len = 1.0 / len_f_theta
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+*/
+      goto __pyx_L6_continue;
+
+      /* "cana/cboolean_node.pyx":105
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:             # <<<<<<<<<<<<<<
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":107
+ *         if len_f_theta == 0:
+ *             continue
+ *         inv_len = 1.0 / len_f_theta             # <<<<<<<<<<<<<<
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+ * 
+*/
+    if (unlikely(__pyx_v_len_f_theta == 0)) {
+      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+      __PYX_ERR(0, 107, __pyx_L1_error)
+    }
+    __pyx_v_inv_len = (1.0 / ((double)__pyx_v_len_f_theta));
+
+    /* "cana/cboolean_node.pyx":108
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+ *         numerator += _sum_group_lengths(f_theta) * inv_len             # <<<<<<<<<<<<<<
+ * 
+ *     return numerator * inv_total_states
+*/
+    __pyx_t_10 = __pyx_f_4cana_13cboolean_node__sum_group_lengths(__pyx_v_f_theta); if (unlikely(__PYX_CHECK_FLOAT_EXCEPTION(__pyx_t_10, ((double)(-1.0))) && PyErr_Occurred())) __PYX_ERR(0, 108, __pyx_L1_error)
+    __pyx_v_numerator = (__pyx_v_numerator + (__pyx_t_10 * __pyx_v_inv_len));
+    __pyx_L6_continue:;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "cana/cboolean_node.pyx":110
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+ * 
+ *     return numerator * inv_total_states             # <<<<<<<<<<<<<<
+ * 
+ * 
+*/
+  __pyx_r = (__pyx_v_numerator * __pyx_v_inv_total_states);
+  goto __pyx_L0;
+
+  /* "cana/cboolean_node.pyx":65
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_f_theta);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_13cboolean_node_1input_symmetry_mean_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_13cboolean_node_input_symmetry_mean_fast, "Fast computation of :meth:`BooleanNode.input_symmetry_mean`.\n\n    Parameters\n    ----------\n    ts_coverage: dict\n        Mapping of LUT entries to the list of covering Two-Symbol schemata.\n    k: int\n        Input degree of the Boolean node.\n\n    Returns\n    -------\n    float\n        Mean number of permutable inputs over the LUT entries.\n    ");
+static PyMethodDef __pyx_mdef_4cana_13cboolean_node_1input_symmetry_mean_fast = {"input_symmetry_mean_fast", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_13cboolean_node_1input_symmetry_mean_fast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_13cboolean_node_input_symmetry_mean_fast};
+static PyObject *__pyx_pw_4cana_13cboolean_node_1input_symmetry_mean_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_ts_coverage = 0;
+  int __pyx_v_k;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[2] = {0,0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("input_symmetry_mean_fast (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ts_coverage,&__pyx_mstate_global->__pyx_n_u_k,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 65, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  2:
+        values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 65, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 65, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "input_symmetry_mean_fast", 0) < (0)) __PYX_ERR(0, 65, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 2; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("input_symmetry_mean_fast", 1, 2, 2, i); __PYX_ERR(0, 65, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 2)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 65, __pyx_L3_error)
+      values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 65, __pyx_L3_error)
+    }
+    __pyx_v_ts_coverage = ((PyObject*)values[0]);
+    __pyx_v_k = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 68, __pyx_L3_error)
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("input_symmetry_mean_fast", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 65, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ts_coverage), (&PyDict_Type), 1, "ts_coverage", 1))) __PYX_ERR(0, 68, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4cana_13cboolean_node_input_symmetry_mean_fast(__pyx_self, __pyx_v_ts_coverage, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4cana_13cboolean_node_input_symmetry_mean_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ts_coverage, int __pyx_v_k) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  double __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("input_symmetry_mean_fast", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_13cboolean_node_input_symmetry_mean_fast(__pyx_v_ts_coverage, __pyx_v_k, 1); if (unlikely(__pyx_t_1 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "cana/cboolean_node.pyx":113
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+
+static PyObject *__pyx_pw_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+static double __pyx_f_4cana_13cboolean_node_input_symmetry_mean_annigen_fast(PyObject *__pyx_v_ts_coverage, CYTHON_UNUSED int __pyx_skip_dispatch) {
+  double __pyx_v_numerator;
+  double __pyx_v_inv_len;
+  Py_ssize_t __pyx_v_len_f_theta;
+  Py_ssize_t __pyx_v_coverage_count;
+  PyObject *__pyx_v_f_theta = 0;
+  double __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  Py_ssize_t __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  int __pyx_t_8;
+  double __pyx_t_9;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("input_symmetry_mean_annigen_fast", 0);
+
+  /* "cana/cboolean_node.pyx":118
+ * cpdef double input_symmetry_mean_annigen_fast(dict ts_coverage):
+ *     """Fast computation of :meth:`BooleanNode.input_symmetry_mean_anni_gen`."""
+ *     cdef double numerator = 0.0             # <<<<<<<<<<<<<<
+ *     cdef double inv_len
+ *     cdef Py_ssize_t len_f_theta
+*/
+  __pyx_v_numerator = 0.0;
+
+  /* "cana/cboolean_node.pyx":121
+ *     cdef double inv_len
+ *     cdef Py_ssize_t len_f_theta
+ *     cdef Py_ssize_t coverage_count = 0             # <<<<<<<<<<<<<<
+ *     cdef list f_theta
+ * 
+*/
+  __pyx_v_coverage_count = 0;
+
+  /* "cana/cboolean_node.pyx":124
+ *     cdef list f_theta
+ * 
+ *     if ts_coverage is None:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+*/
+  __pyx_t_1 = (__pyx_v_ts_coverage == ((PyObject*)Py_None));
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":125
+ * 
+ *     if ts_coverage is None:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":124
+ *     cdef list f_theta
+ * 
+ *     if ts_coverage is None:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":126
+ *     if ts_coverage is None:
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  __pyx_t_2 = PyDict_Size(__pyx_v_ts_coverage); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1L))) __PYX_ERR(0, 126, __pyx_L1_error)
+  __pyx_t_1 = (__pyx_t_2 == 0);
+  if (__pyx_t_1) {
+
+    /* "cana/cboolean_node.pyx":127
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ * 
+ *     for f_theta in ts_coverage.values():
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":126
+ *     if ts_coverage is None:
+ *         return 0.0
+ *     if PyDict_Size(ts_coverage) == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ * 
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":129
+ *         return 0.0
+ * 
+ *     for f_theta in ts_coverage.values():             # <<<<<<<<<<<<<<
+ *         if not f_theta:
+ *             continue
+*/
+  __pyx_t_2 = 0;
+  if (unlikely(__pyx_v_ts_coverage == Py_None)) {
+    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values");
+    __PYX_ERR(0, 129, __pyx_L1_error)
+  }
+  __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_ts_coverage, 1, __pyx_mstate_global->__pyx_n_u_values, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_3);
+  __pyx_t_3 = __pyx_t_6;
+  __pyx_t_6 = 0;
+  while (1) {
+    __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_4, &__pyx_t_2, NULL, &__pyx_t_6, NULL, __pyx_t_5);
+    if (unlikely(__pyx_t_7 == 0)) break;
+    if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 129, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    if (!(likely(PyList_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_6))) __PYX_ERR(0, 129, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_6));
+    __pyx_t_6 = 0;
+
+    /* "cana/cboolean_node.pyx":130
+ * 
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(f_theta):
+*/
+    if (__pyx_v_f_theta == Py_None) __pyx_t_1 = 0;
+    else
+    {
+      Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_v_f_theta);
+      if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 130, __pyx_L1_error)
+      __pyx_t_1 = (__pyx_temp != 0);
+    }
+
+    __pyx_t_8 = (!__pyx_t_1);
+    if (__pyx_t_8) {
+
+      /* "cana/cboolean_node.pyx":131
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:
+ *             continue             # <<<<<<<<<<<<<<
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)
+*/
+      goto __pyx_L5_continue;
+
+      /* "cana/cboolean_node.pyx":130
+ * 
+ *     for f_theta in ts_coverage.values():
+ *         if not f_theta:             # <<<<<<<<<<<<<<
+ *             continue
+ *         if not PyList_Check(f_theta):
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":132
+ *         if not f_theta:
+ *             continue
+ *         if not PyList_Check(f_theta):             # <<<<<<<<<<<<<<
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+*/
+    __pyx_t_8 = (!PyList_Check(__pyx_v_f_theta));
+    if (__pyx_t_8) {
+
+      /* "cana/cboolean_node.pyx":133
+ *             continue
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)             # <<<<<<<<<<<<<<
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+*/
+      __pyx_t_6 = PySequence_List(__pyx_v_f_theta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 133, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_6));
+      __pyx_t_6 = 0;
+
+      /* "cana/cboolean_node.pyx":132
+ *         if not f_theta:
+ *             continue
+ *         if not PyList_Check(f_theta):             # <<<<<<<<<<<<<<
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":134
+ *         if not PyList_Check(f_theta):
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta             # <<<<<<<<<<<<<<
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:
+*/
+    __pyx_t_6 = __pyx_v_f_theta;
+    __Pyx_INCREF(__pyx_t_6);
+    __Pyx_DECREF_SET(__pyx_v_f_theta, ((PyObject*)__pyx_t_6));
+    __pyx_t_6 = 0;
+
+    /* "cana/cboolean_node.pyx":135
+ *             f_theta = list(f_theta)
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)             # <<<<<<<<<<<<<<
+ *         if len_f_theta == 0:
+ *             continue
+*/
+    __pyx_v_len_f_theta = PyList_GET_SIZE(__pyx_v_f_theta);
+
+    /* "cana/cboolean_node.pyx":136
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:             # <<<<<<<<<<<<<<
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+*/
+    __pyx_t_8 = (__pyx_v_len_f_theta == 0);
+    if (__pyx_t_8) {
+
+      /* "cana/cboolean_node.pyx":137
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:
+ *             continue             # <<<<<<<<<<<<<<
+ *         inv_len = 1.0 / len_f_theta
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+*/
+      goto __pyx_L5_continue;
+
+      /* "cana/cboolean_node.pyx":136
+ *         f_theta = <list>f_theta
+ *         len_f_theta = PyList_GET_SIZE(f_theta)
+ *         if len_f_theta == 0:             # <<<<<<<<<<<<<<
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+*/
+    }
+
+    /* "cana/cboolean_node.pyx":138
+ *         if len_f_theta == 0:
+ *             continue
+ *         inv_len = 1.0 / len_f_theta             # <<<<<<<<<<<<<<
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+ *         coverage_count += 1
+*/
+    if (unlikely(__pyx_v_len_f_theta == 0)) {
+      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+      __PYX_ERR(0, 138, __pyx_L1_error)
+    }
+    __pyx_v_inv_len = (1.0 / ((double)__pyx_v_len_f_theta));
+
+    /* "cana/cboolean_node.pyx":139
+ *             continue
+ *         inv_len = 1.0 / len_f_theta
+ *         numerator += _sum_group_lengths(f_theta) * inv_len             # <<<<<<<<<<<<<<
+ *         coverage_count += 1
+ * 
+*/
+    __pyx_t_9 = __pyx_f_4cana_13cboolean_node__sum_group_lengths(__pyx_v_f_theta); if (unlikely(__PYX_CHECK_FLOAT_EXCEPTION(__pyx_t_9, ((double)(-1.0))) && PyErr_Occurred())) __PYX_ERR(0, 139, __pyx_L1_error)
+    __pyx_v_numerator = (__pyx_v_numerator + (__pyx_t_9 * __pyx_v_inv_len));
+
+    /* "cana/cboolean_node.pyx":140
+ *         inv_len = 1.0 / len_f_theta
+ *         numerator += _sum_group_lengths(f_theta) * inv_len
+ *         coverage_count += 1             # <<<<<<<<<<<<<<
+ * 
+ *     if coverage_count == 0:
+*/
+    __pyx_v_coverage_count = (__pyx_v_coverage_count + 1);
+    __pyx_L5_continue:;
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "cana/cboolean_node.pyx":142
+ *         coverage_count += 1
+ * 
+ *     if coverage_count == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     return numerator / coverage_count
+*/
+  __pyx_t_8 = (__pyx_v_coverage_count == 0);
+  if (__pyx_t_8) {
+
+    /* "cana/cboolean_node.pyx":143
+ * 
+ *     if coverage_count == 0:
+ *         return 0.0             # <<<<<<<<<<<<<<
+ *     return numerator / coverage_count
+*/
+    __pyx_r = 0.0;
+    goto __pyx_L0;
+
+    /* "cana/cboolean_node.pyx":142
+ *         coverage_count += 1
+ * 
+ *     if coverage_count == 0:             # <<<<<<<<<<<<<<
+ *         return 0.0
+ *     return numerator / coverage_count
+*/
+  }
+
+  /* "cana/cboolean_node.pyx":144
+ *     if coverage_count == 0:
+ *         return 0.0
+ *     return numerator / coverage_count             # <<<<<<<<<<<<<<
+*/
+  if (unlikely(__pyx_v_coverage_count == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 144, __pyx_L1_error)
+  }
+  __pyx_r = (__pyx_v_numerator / ((double)__pyx_v_coverage_count));
+  goto __pyx_L0;
+
+  /* "cana/cboolean_node.pyx":113
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_annigen_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_f_theta);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+); /*proto*/
+PyDoc_STRVAR(__pyx_doc_4cana_13cboolean_node_2input_symmetry_mean_annigen_fast, "Fast computation of :meth:`BooleanNode.input_symmetry_mean_anni_gen`.");
+static PyMethodDef __pyx_mdef_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast = {"input_symmetry_mean_annigen_fast", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cana_13cboolean_node_2input_symmetry_mean_annigen_fast};
+static PyObject *__pyx_pw_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast(PyObject *__pyx_self, 
+#if CYTHON_METH_FASTCALL
+PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
+#else
+PyObject *__pyx_args, PyObject *__pyx_kwds
+#endif
+) {
+  PyObject *__pyx_v_ts_coverage = 0;
+  #if !CYTHON_METH_FASTCALL
+  CYTHON_UNUSED Py_ssize_t __pyx_nargs;
+  #endif
+  CYTHON_UNUSED PyObject *const *__pyx_kwvalues;
+  PyObject* values[1] = {0};
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("input_symmetry_mean_annigen_fast (wrapper)", 0);
+  #if !CYTHON_METH_FASTCALL
+  #if CYTHON_ASSUME_SAFE_SIZE
+  __pyx_nargs = PyTuple_GET_SIZE(__pyx_args);
+  #else
+  __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL;
+  #endif
+  #endif
+  __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs);
+  {
+    PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_ts_coverage,0};
+    const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0;
+    if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 113, __pyx_L3_error)
+    if (__pyx_kwds_len > 0) {
+      switch (__pyx_nargs) {
+        case  1:
+        values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+        if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 113, __pyx_L3_error)
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      const Py_ssize_t kwd_pos_args = __pyx_nargs;
+      if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "input_symmetry_mean_annigen_fast", 0) < (0)) __PYX_ERR(0, 113, __pyx_L3_error)
+      for (Py_ssize_t i = __pyx_nargs; i < 1; i++) {
+        if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("input_symmetry_mean_annigen_fast", 1, 1, 1, i); __PYX_ERR(0, 113, __pyx_L3_error) }
+      }
+    } else if (unlikely(__pyx_nargs != 1)) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0);
+      if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 113, __pyx_L3_error)
+    }
+    __pyx_v_ts_coverage = ((PyObject*)values[0]);
+  }
+  goto __pyx_L6_skip;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("input_symmetry_mean_annigen_fast", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 113, __pyx_L3_error)
+  __pyx_L6_skip:;
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_annigen_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ts_coverage), (&PyDict_Type), 1, "ts_coverage", 1))) __PYX_ERR(0, 116, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4cana_13cboolean_node_2input_symmetry_mean_annigen_fast(__pyx_self, __pyx_v_ts_coverage);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  goto __pyx_L7_cleaned_up;
+  __pyx_L0:;
+  for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) {
+    Py_XDECREF(values[__pyx_temp]);
+  }
+  __pyx_L7_cleaned_up:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4cana_13cboolean_node_2input_symmetry_mean_annigen_fast(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ts_coverage) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  double __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("input_symmetry_mean_annigen_fast", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_f_4cana_13cboolean_node_input_symmetry_mean_annigen_fast(__pyx_v_ts_coverage, 1); if (unlikely(__pyx_t_1 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L1_error)
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("cana.cboolean_node.input_symmetry_mean_annigen_fast", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* #### Code section: module_exttypes ### */
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+/* #### Code section: initfunc_declarations ### */
+static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/
+static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/
+/* #### Code section: init_module ### */
+
+static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
+  /*--- Global init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
+  /*--- Variable export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
+  /*--- Function export code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
+  /*--- Type init code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
+  /*--- Type import code ---*/
+  __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_2_0(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type",
+  #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000
+  sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyTypeObject),
+  #elif CYTHON_COMPILING_IN_LIMITED_API
+  0, 0,
+  #else
+  sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyHeapTypeObject),
+  #endif
+  __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(1, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
+  /*--- Variable import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
+  /*--- Function import code ---*/
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
+static int __pyx_pymod_exec_cboolean_node(PyObject* module); /*proto*/
+static PyModuleDef_Slot __pyx_moduledef_slots[] = {
+  {Py_mod_create, (void*)__pyx_pymod_create},
+  {Py_mod_exec, (void*)__pyx_pymod_exec_cboolean_node},
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+  {Py_mod_gil, Py_MOD_GIL_USED},
+  #endif
+  #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE
+  {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
+  #endif
+  {0, NULL}
+};
+#endif
+
+#ifdef __cplusplus
+namespace {
+  struct PyModuleDef __pyx_moduledef =
+  #else
+  static struct PyModuleDef __pyx_moduledef =
+  #endif
+  {
+      PyModuleDef_HEAD_INIT,
+      "cboolean_node",
+      __pyx_k_Cython_accelerated_helpers_for_c, /* m_doc */
+    #if CYTHON_USE_MODULE_STATE
+      sizeof(__pyx_mstatetype), /* m_size */
+    #else
+      (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */
+    #endif
+      __pyx_methods /* m_methods */,
+    #if CYTHON_PEP489_MULTI_PHASE_INIT
+      __pyx_moduledef_slots, /* m_slots */
+    #else
+      NULL, /* m_reload */
+    #endif
+    #if CYTHON_USE_MODULE_STATE
+      __pyx_m_traverse, /* m_traverse */
+      __pyx_m_clear, /* m_clear */
+      NULL /* m_free */
+    #else
+      NULL, /* m_traverse */
+      NULL, /* m_clear */
+      NULL /* m_free */
+    #endif
+  };
+  #ifdef __cplusplus
+} /* anonymous namespace */
+#endif
+
+/* PyModInitFuncType */
+#ifndef CYTHON_NO_PYINIT_EXPORT
+  #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
+#else
+  #ifdef __cplusplus
+  #define __Pyx_PyMODINIT_FUNC extern "C" PyObject *
+  #else
+  #define __Pyx_PyMODINIT_FUNC PyObject *
+  #endif
+#endif
+
+__Pyx_PyMODINIT_FUNC PyInit_cboolean_node(void) CYTHON_SMALL_CODE; /*proto*/
+__Pyx_PyMODINIT_FUNC PyInit_cboolean_node(void)
+#if CYTHON_PEP489_MULTI_PHASE_INIT
+{
+  return PyModuleDef_Init(&__pyx_moduledef);
+}
+/* ModuleCreationPEP489 */
+#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\
+      || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000))
+static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) {
+    {
+        PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think
+        if (!module) {
+            PyErr_Clear(); // just try the 3.8-3.12 version
+            module = PyImport_ImportModule("_xxsubinterpreters");
+            if (!module) goto bad;
+        }
+        PyObject *current = PyObject_CallMethod(module, "get_current", NULL);
+        Py_DECREF(module);
+        if (!current) goto bad;
+        if (PyTuple_Check(current)) {
+            PyObject *new_current = PySequence_GetItem(current, 0);
+            Py_DECREF(current);
+            current = new_current;
+            if (!new_current) goto bad;
+        }
+        long long as_c_int = PyLong_AsLongLong(current);
+        Py_DECREF(current);
+        return as_c_int;
+    }
+  bad:
+    PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n");
+    return -1;
+}
+#endif
+#if !CYTHON_USE_MODULE_STATE
+static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) {
+    static PY_INT64_T main_interpreter_id = -1;
+#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000
+    PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
+#elif CYTHON_COMPILING_IN_GRAAL
+    PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get());
+#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\
+      || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000))
+    PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId();
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get());
+#else
+    PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp);
+#endif
+    if (unlikely(current_id == -1)) {
+        return -1;
+    }
+    if (main_interpreter_id == -1) {
+        main_interpreter_id = current_id;
+        return 0;
+    } else if (unlikely(main_interpreter_id != current_id)) {
+        PyErr_SetString(
+            PyExc_ImportError,
+            "Interpreter change detected - this module can only be loaded into one interpreter per process.");
+        return -1;
+    }
+    return 0;
+}
+#endif
+static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none)
+{
+    PyObject *value = PyObject_GetAttrString(spec, from_name);
+    int result = 0;
+    if (likely(value)) {
+        if (allow_none || value != Py_None) {
+            result = PyDict_SetItemString(moddict, to_name, value);
+        }
+        Py_DECREF(value);
+    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+    } else {
+        result = -1;
+    }
+    return result;
+}
+static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) {
+    PyObject *module = NULL, *moddict, *modname;
+    CYTHON_UNUSED_VAR(def);
+    #if !CYTHON_USE_MODULE_STATE
+    if (__Pyx_check_single_interpreter())
+        return NULL;
+    #endif
+    if (__pyx_m)
+        return __Pyx_NewRef(__pyx_m);
+    modname = PyObject_GetAttrString(spec, "name");
+    if (unlikely(!modname)) goto bad;
+    module = PyModule_NewObject(modname);
+    Py_DECREF(modname);
+    if (unlikely(!module)) goto bad;
+    moddict = PyModule_GetDict(module);
+    if (unlikely(!moddict)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad;
+    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad;
+    return module;
+bad:
+    Py_XDECREF(module);
+    return NULL;
+}
+
+
+static CYTHON_SMALL_CODE int __pyx_pymod_exec_cboolean_node(PyObject *__pyx_pyinit_module)
+#endif
+{
+  int stringtab_initialized = 0;
+  #if CYTHON_USE_MODULE_STATE
+  int pystate_addmodule_run = 0;
+  #endif
+  __pyx_mstatetype *__pyx_mstate = NULL;
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  if (__pyx_m) {
+    if (__pyx_m == __pyx_pyinit_module) return 0;
+    PyErr_SetString(PyExc_RuntimeError, "Module 'cboolean_node' has already been imported. Re-initialisation is not supported.");
+    return -1;
+  }
+  #else
+  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
+  #endif
+  /*--- Module creation code ---*/
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  __pyx_t_1 = __pyx_pyinit_module;
+  Py_INCREF(__pyx_t_1);
+  #else
+  __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+  #endif
+  #if CYTHON_USE_MODULE_STATE
+  {
+    int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef);
+    __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "cboolean_node" pseudovariable */
+    if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    pystate_addmodule_run = 1;
+  }
+  #else
+  __pyx_m = __pyx_t_1;
+  #endif
+  #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+  PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED);
+  #endif
+  __pyx_mstate = __pyx_mstate_global;
+  CYTHON_UNUSED_VAR(__pyx_t_1);
+  __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_mstate->__pyx_d);
+  __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  /* ImportRefnannyAPI */
+  #if CYTHON_REFNANNY
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+  if (!__Pyx_RefNanny) {
+    PyErr_Clear();
+    __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+    if (!__Pyx_RefNanny)
+        Py_FatalError("failed to import 'refnanny' module");
+  }
+  #endif
+  
+__Pyx_RefNannySetupContext("PyInit_cboolean_node", 0);
+  __Pyx_init_runtime_version();
+  if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Library function declarations ---*/
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  stringtab_initialized = 1;
+  if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__pyx_module_is_main_cana__cboolean_node) {
+    if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  }
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "cana.cboolean_node")) {
+      if (unlikely((PyDict_SetItemString(modules, "cana.cboolean_node", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+    }
+  }
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  /*--- Global type/function init code ---*/
+  (void)__Pyx_modinit_global_init_code(__pyx_mstate);
+  (void)__Pyx_modinit_variable_export_code(__pyx_mstate);
+  (void)__Pyx_modinit_function_export_code(__pyx_mstate);
+  (void)__Pyx_modinit_type_init_code(__pyx_mstate);
+  if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error)
+  (void)__Pyx_modinit_variable_import_code(__pyx_mstate);
+  (void)__Pyx_modinit_function_import_code(__pyx_mstate);
+  /*--- Execution code ---*/
+
+  /* "cana/cboolean_node.pyx":65
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_13cboolean_node_1input_symmetry_mean_fast, 0, __pyx_mstate_global->__pyx_n_u_input_symmetry_mean_fast, NULL, __pyx_mstate_global->__pyx_n_u_cana_cboolean_node, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
+  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
+  #endif
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_input_symmetry_mean_fast, __pyx_t_2) < (0)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "cana/cboolean_node.pyx":113
+ * 
+ * 
+ * @cython.boundscheck(False)             # <<<<<<<<<<<<<<
+ * @cython.wraparound(False)
+ * @cython.nonecheck(False)
+*/
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4cana_13cboolean_node_3input_symmetry_mean_annigen_fast, 0, __pyx_mstate_global->__pyx_n_u_input_symmetry_mean_annigen_fast, NULL, __pyx_mstate_global->__pyx_n_u_cana_cboolean_node, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000
+  PyUnstable_Object_EnableDeferredRefcount(__pyx_t_2);
+  #endif
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_input_symmetry_mean_annigen_fast, __pyx_t_2) < (0)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "cana/cboolean_node.pyx":1
+ * # cython: language_level=3, boundscheck=False, wraparound=False, nonecheck=False             # <<<<<<<<<<<<<<
+ * """Cython-accelerated helpers for ``cana.boolean_node``."""
+ * 
+*/
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_2) < (0)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  if (__pyx_m) {
+    if (__pyx_mstate->__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init cana.cboolean_node", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init cana.cboolean_node");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #else
+  return __pyx_m;
+  #endif
+}
+/* #### Code section: pystring_table ### */
+/* #### Code section: cached_builtins ### */
+
+static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) {
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+
+  /* Cached unbound methods */
+  __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type;
+  __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values;
+  return 0;
+}
+/* #### Code section: cached_constants ### */
+
+static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) {
+  __Pyx_RefNannyDeclarations
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+  __Pyx_RefNannyFinishContext();
+  return 0;
+}
+/* #### Code section: init_constants ### */
+
+static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) {
+  CYTHON_UNUSED_VAR(__pyx_mstate);
+  {
+    const struct { const unsigned int length: 8; } index[] = {{1},{179},{8},{22},{20},{18},{18},{18},{8},{32},{24},{13},{5},{1},{8},{10},{8},{3},{12},{12},{10},{8},{11},{6},{176},{173}};
+    #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (592 bytes) */
+const char* const cstring = "BZh91AY&SY\215\357\376\\\000\000a\377\373\357\356\273\227e\203\254^\257!p\000\277\377\377l\300@@@@@@\000@@@\000@\000@\001\375q\300s\rSSjz\201\220\006\206\200\000\006\201\204\000\000\032\032\000\tT\362\023&\206\247\250i\247\245=S@\032\032\000\0004\000\000\007\244\002T\364\220HoT\323\312\032\036\246\206@\000\000\000\000\000\006\324z\202RP\020\321\35144\310\300\206FF\003S\t\202m\020d\032l\032\232\234Q\272T\227\221\260\376\034E\246\364R\223\204 \016@\210\202\014\020\205\222\202\020\241\360\306\007>\000\240\344\010\007\320o\300\360\334\0209!\035\272\322\3236\031\271\265\245\013\334\367\033\313\350\243\302\025\336\322I{Qe\3021\2217\246\326\251\273\337\n\320\362\235\232\314\013\2022YX\037\311\303l1\321\030\204~4\201=\0231\237\325\334\367\227\356-_\017sR\300\223\255a\037^\351\256\251H\350\021,J%`h\213q9\342zN\271\361C]\315\365\246W}\300&0\353\350\317I\244\352\322\322\312\024.\231\272D\234o\316\220\367\343\320rPv\307%\303\010\275r\207\001\252B\274\301\264\321\014w\252\271\0055\275\333x\364C\215\312\345\254\273\252\267\354\221\235\216\311\265L\206\355{\250i\0224\246e\365\033wl|\334\373\036\303K\026\211\216\363d\324v\010GH\326Z6j\330-H`s\016\263\235b\274`\250+\024\320\350Y\007>\364\252l+\025\030HF\027Wi\223\250j\231\r\251~\003y\004mq'\233\365\2619GH\014u!8\262\321\017\023\\\312(\306-\032>\227c\266\247\240\352\232+$*\360k\214F\344hT\037'\306\320\3026\021\203\353\036\330\215cR\353x^G,\355\347\346@\276k1\226p\346]T\3617:\332\006B?W\2350\nQ!\240>=\202\350\241B\317\220\336F6\216\016\r\220m\006G\315\325\r\005n\362h\337)$\244\360\353\334\317\213\030u<L\244\250\006\212\203\345\023\350\206\021E\214\223\243\371\252\210b\240R\230\204bg\213\302\3629\005\017\361w$S\205\t\010\336\377\345\300";
+    PyObject *data = __Pyx_DecompressString(cstring, 592, 2);
+    if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error)
+    const char* const bytes = __Pyx_PyBytes_AsString(data);
+    #if !CYTHON_ASSUME_SAFE_MACROS
+    if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) }
+    #endif
+    #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (504 bytes) */
+const char* const cstring = "x\332\265Q\313j\0331\024u\250\235N\261K\251CR(m\221\241\330\253N\010\361\242\364A1}@7\301\316\017\010\215\346\332V;#\215G\032\223\241\201z9K-\265\234e\227\371\224.\275\364'\370\023z\345\204\320B\351\256ZHW\347\236s\356\231\321\2733e\200\23093\344}i\346J\022\241I\014\211\210 g\006\222\222h\223\013n \367$I\306\037\307/\206/\207\204\311\230\344\360\005\270\321D\027\021O\230\326\240\211\232\222\250\020\211\021\222\2302\003\035\222\317SR\252\202H\200\230\030E2\344\375.0s\220D\203\361\005\0310)\225aF(IQ.\344l@b\221\343\020\261\004\257\376\304\022\r!\213c\212<\340L\262c\036)\225\000\223\210\304\020f\345\005\245c\334\306\345\007LM\317\340\302\234\303\224\351Rr\241B\256rU`8\320^\033\376\241\345\t\342T\340\344\234q\210\030\377J\351\264\220\234\"\226\025\206\3522M\301\344%M\275\002\223\212\031H\212\326\346o}\217S\241\351\355Da \325h\2312\034\201+Uq\221\200\257$K\361\314TF\351\242`\311\365\225R\374)7-\254b\374\206\"1\224\032\320~\367\306K|\241\031,YR\200^\355m\367\033\375\301\366Y\243\365\324\215\266\235F+X]\332S\313\326\301\203j\261n\336]}\263=\373\266\276S\237\334\"yuP\215v\267M\363\2215\356\324E\276\277i\006U\333\276v\263z\262\016\332\325\020\311\235\373\327\325\245;q\243u\347\310\306\256\347\320\250k\373no\035\034YUOj\3469o\254v\275\035\277k\237\333\310w\017\177\036\016\352\305\217{W\335+\364nW\257\354\271]\354\362\206\307\233\346\023L\273\337h\365\353\211?\376\035\372\177&[\007\217]o\203#\277[\356\036\336\004\270\t\373\013\366\3531=";
+    PyObject *data = __Pyx_DecompressString(cstring, 504, 1);
+    if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error)
+    const char* const bytes = __Pyx_PyBytes_AsString(data);
+    #if !CYTHON_ASSUME_SAFE_MACROS
+    if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) }
+    #endif
+    #else /* compression: none (804 bytes) */
+const char* const bytes = "?Note that Cython is deliberately stricter than PEP-484 and rejects subclasses of builtin types. If you need to pass subclasses then set the 'annotation_typing' directive to False.add_notecana/cboolean_node.pyx__Pyx_PyDict_NextRefasyncio.coroutinescana.cboolean_nodecline_in_traceback__func__input_symmetry_mean_annigen_fastinput_symmetry_mean_fast_is_coroutineitemsk__main____module____name__pop__qualname____set_name__setdefault__test__ts_coveragevalues\200\001\360\006\000&'\360\036\000\005\035\230A\360\014\000\005\010\200|\2203\220a\330\010\017\210q\330\004\007\200{\220!\220=\240\003\2401\330\010\017\210q\330\004\007\200r\210\023\210A\330\010\017\210q\340\004\027\220t\2303\230b\240\003\2401\340\004\010\210\013\220;\230g\240Q\330\010\013\2104\210q\330\014\r\330\010\013\2104\210|\2301\230A\330\014\026\220d\230!\2301\330\010\022\220&\230\001\330\010\026\220o\240Q\240a\330\010\013\210<\220s\230!\330\014\r\330\010\022\220$\220b\230\001\330\010\025\320\025'\240q\250\t\260\022\2601\340\004\013\210:\220R\220q\200\001\360\006\000./\340\004\034\230A\360\006\000\005&\240Q\360\006\000\005\010\200|\2203\220a\330\010\017\210q\330\004\007\200{\220!\220=\240\003\2401\330\010\017\210q\340\004\010\210\013\220;\230g\240Q\330\010\013\2104\210q\330\014\r\330\010\013\2104\210|\2301\230A\330\014\026\220d\230!\2301\330\010\022\220&\230\001\330\010\026\220o\240Q\240a\330\010\013\210<\220s\230!\330\014\r\330\010\022\220$\220b\230\001\330\010\025\320\025'\240q\250\t\260\022\2601\330\010\032\230!\340\004\007\200\177\220c\230\021\330\010\017\210q\330\004\013\210:\220R\220q";
+    PyObject *data = NULL;
+    CYTHON_UNUSED_VAR(__Pyx_DecompressString);
+    #endif
+    PyObject **stringtab = __pyx_mstate->__pyx_string_tab;
+    Py_ssize_t pos = 0;
+    for (int i = 0; i < 24; i++) {
+      Py_ssize_t bytes_length = index[i].length;
+      PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL);
+      if (likely(string) && i >= 4) PyUnicode_InternInPlace(&string);
+      if (unlikely(!string)) {
+        Py_XDECREF(data);
+        __PYX_ERR(0, 1, __pyx_L1_error)
+      }
+      stringtab[i] = string;
+      pos += bytes_length;
+    }
+    for (int i = 24; i < 26; i++) {
+      Py_ssize_t bytes_length = index[i].length;
+      PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length);
+      stringtab[i] = string;
+      pos += bytes_length;
+      if (unlikely(!string)) {
+        Py_XDECREF(data);
+        __PYX_ERR(0, 1, __pyx_L1_error)
+      }
+    }
+    Py_XDECREF(data);
+    for (Py_ssize_t i = 0; i < 26; i++) {
+      if (unlikely(PyObject_Hash(stringtab[i]) == -1)) {
+        __PYX_ERR(0, 1, __pyx_L1_error)
+      }
+    }
+    #if CYTHON_IMMORTAL_CONSTANTS
+    {
+      PyObject **table = stringtab + 24;
+      for (Py_ssize_t i=0; i<2; ++i) {
+        #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+        Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL);
+        #else
+        Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT);
+        #endif
+      }
+    }
+    #endif
+  }
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: init_codeobjects ### */
+typedef struct {
+    unsigned int argcount : 2;
+    unsigned int num_posonly_args : 1;
+    unsigned int num_kwonly_args : 1;
+    unsigned int nlocals : 2;
+    unsigned int flags : 10;
+    unsigned int first_line : 7;
+} __Pyx_PyCode_New_function_description;
+/* NewCodeObj.proto */
+static PyObject* __Pyx_PyCode_New(
+        const __Pyx_PyCode_New_function_description descr,
+        PyObject * const *varnames,
+        PyObject *filename,
+        PyObject *funcname,
+        PyObject *line_table,
+        PyObject *tuple_dedup_map
+);
+
+
+static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) {
+  PyObject* tuple_dedup_map = PyDict_New();
+  if (unlikely(!tuple_dedup_map)) return -1;
+  {
+    const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 65};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ts_coverage, __pyx_mstate->__pyx_n_u_k};
+    __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_cana_cboolean_node_pyx, __pyx_mstate->__pyx_n_u_input_symmetry_mean_fast, __pyx_mstate->__pyx_kp_b_iso88591_A_3a_q_1_q_r_A_q_t3b_1_gQ_4q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad;
+  }
+  {
+    const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113};
+    PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_ts_coverage};
+    __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_cana_cboolean_node_pyx, __pyx_mstate->__pyx_n_u_input_symmetry_mean_annigen_fast, __pyx_mstate->__pyx_kp_b_iso88591_A_Q_3a_q_1_q_gQ_4q_4_1A_d_1_oQa, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad;
+  }
+  Py_DECREF(tuple_dedup_map);
+  return 0;
+  bad:
+  Py_DECREF(tuple_dedup_map);
+  return -1;
+}
+/* #### Code section: init_globals ### */
+
+static int __Pyx_InitGlobals(void) {
+  /* PythonCompatibility.init */
+  if (likely(__Pyx_init_co_variables() == 0)); else
+  
+  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* CommonTypesMetaclass.init */
+  if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else
+  
+  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* CachedMethodType.init */
+  #if CYTHON_COMPILING_IN_LIMITED_API
+  {
+      PyObject *typesModule=NULL;
+      typesModule = PyImport_ImportModule("types");
+      if (typesModule) {
+          __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType");
+          Py_DECREF(typesModule);
+      }
+  } // error handling follows
+  #endif
+  
+  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  /* CythonFunctionShared.init */
+  if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else
+  
+  if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error)
+
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* IterFinish */
+static CYTHON_INLINE int __Pyx_IterFinish(void) {
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
+    if (unlikely(exc_type)) {
+        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
+            return -1;
+        __Pyx_PyErr_Clear();
+        return 0;
+    }
+    return 0;
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API
+  #if PY_VERSION_HEX < 0x03090000
+    #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable)
+  #elif CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) {
+    PyTypeObject *tp = Py_TYPE(callable);
+    #if defined(__Pyx_CyFunction_USED)
+    if (__Pyx_CyFunction_CheckExact(callable)) {
+        return __Pyx_CyFunction_func_vectorcall(callable);
+    }
+    #endif
+    if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) {
+        return NULL;
+    }
+    assert(PyCallable_Check(callable));
+    Py_ssize_t offset = tp->tp_vectorcall_offset;
+    assert(offset > 0);
+    vectorcallfunc ptr;
+    memcpy(&ptr, (char *) callable + offset, sizeof(ptr));
+    return ptr;
+}
+  #else
+    #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable)
+  #endif
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+          #if CYTHON_COMPILING_IN_LIMITED_API
+            return PyObject_Vectorcall(func, args, _nargs, NULL);
+          #else
+            vectorcallfunc f = __Pyx_PyVectorcall_Function(func);
+            if (f) {
+                return f(func, args, _nargs, NULL);
+            }
+          #endif
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetMethod */
+#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)))
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetFullyQualifiedName(tp);
+    PyErr_Format(PyExc_AttributeError,
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+#endif
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))
+    PyObject *args[1] = {obj};
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_CallNoArg;
+    return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+#endif
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseTooManyValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* UnpackItemEndCheck */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    }
+    return __Pyx_IterFinish();
+}
+
+/* RaiseNoneIterError */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* UnpackTupleError */
+static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
+    if (t == Py_None) {
+      __Pyx_RaiseNoneNotIterableError();
+    } else {
+      Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t);
+ #if !CYTHON_ASSUME_SAFE_SIZE
+      if (unlikely(size < 0)) return;
+ #endif
+      if (size < index) {
+        __Pyx_RaiseNeedMoreValuesError(size);
+      } else {
+        __Pyx_RaiseTooManyValuesError(index);
+      }
+    }
+}
+
+/* UnpackTuple2 */
+static CYTHON_INLINE int __Pyx_unpack_tuple2(
+        PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) {
+    if (likely(is_tuple || PyTuple_Check(tuple))) {
+        Py_ssize_t size;
+        if (has_known_size) {
+            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
+        }
+        size = __Pyx_PyTuple_GET_SIZE(tuple);
+        if (likely(size == 2)) {
+            return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple);
+        }
+        if (size >= 0) {
+            __Pyx_UnpackTupleError(tuple, 2);
+        }
+        return -1;
+    } else {
+        return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple);
+    }
+}
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
+    PyObject *value1 = NULL, *value2 = NULL;
+#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
+    value1 = __Pyx_PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
+    value2 = __Pyx_PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
+#else
+    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
+    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
+#endif
+    if (decref_tuple) {
+        Py_DECREF(tuple);
+    }
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS
+bad:
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+#endif
+}
+static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
+                                       int has_known_size, int decref_tuple) {
+    Py_ssize_t index;
+    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
+    iternextfunc iternext;
+    iter = PyObject_GetIter(tuple);
+    if (unlikely(!iter)) goto bad;
+    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
+    iternext = __Pyx_PyObject_GetIterNextFunc(iter);
+    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
+    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
+    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
+    Py_DECREF(iter);
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+unpacking_failed:
+    if (!has_known_size && __Pyx_IterFinish() == 0)
+        __Pyx_RaiseNeedMoreValuesError(index);
+bad:
+    Py_XDECREF(iter);
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+}
+
+/* dict_iter */
+#if CYTHON_COMPILING_IN_PYPY
+#include <string.h>
+#endif
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
+    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
+    *p_source_is_dict = is_dict;
+    if (is_dict) {
+#if !CYTHON_COMPILING_IN_PYPY
+        *p_orig_length = PyDict_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+#else
+        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
+        PyObject **pp = NULL;
+        if (method_name) {
+            const char *name = PyUnicode_AsUTF8(method_name);
+            if (strcmp(name, "iteritems") == 0) pp = &py_items;
+            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
+            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
+            if (pp) {
+                if (!*pp) {
+                    *pp = PyUnicode_FromString(name + 4);
+                    if (!*pp)
+                        return NULL;
+                }
+                method_name = *pp;
+            }
+        }
+#endif
+    }
+    *p_orig_length = 0;
+    if (method_name) {
+        PyObject* iter;
+        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
+        if (!iterable)
+            return NULL;
+#if !CYTHON_COMPILING_IN_PYPY
+        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
+            return iterable;
+#endif
+        iter = PyObject_GetIter(iterable);
+        Py_DECREF(iterable);
+        return iter;
+    }
+    return PyObject_GetIter(iterable);
+}
+#if !CYTHON_AVOID_BORROWED_REFS
+static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem) {
+    PyObject *key, *value;
+    if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+        PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
+        return -1;
+    }
+    if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
+        return 0;
+    }
+    if (pitem) {
+        PyObject* tuple = PyTuple_New(2);
+        if (unlikely(!tuple)) {
+            return -1;
+        }
+        Py_INCREF(key);
+        Py_INCREF(value);
+        #if CYTHON_ASSUME_SAFE_MACROS
+        PyTuple_SET_ITEM(tuple, 0, key);
+        PyTuple_SET_ITEM(tuple, 1, value);
+        #else
+        if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) {
+            Py_DECREF(value);
+            Py_DECREF(tuple);
+            return -1;
+        }
+        if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) {
+            Py_DECREF(tuple);
+            return -1;
+        }
+        #endif
+        *pitem = tuple;
+    } else {
+        if (pkey) {
+            Py_INCREF(key);
+            *pkey = key;
+        }
+        if (pvalue) {
+            Py_INCREF(value);
+            *pvalue = value;
+        }
+    }
+    return 1;
+}
+#endif
+static CYTHON_INLINE int __Pyx_dict_iter_next(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
+    PyObject* next_item;
+#if !CYTHON_AVOID_BORROWED_REFS
+    if (source_is_dict) {
+        int result;
+#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_BEGIN_CRITICAL_SECTION(iter_obj);
+#endif
+        result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem);
+#if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_END_CRITICAL_SECTION();
+#endif
+        return result;
+    } else if (PyTuple_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(tuple_size < 0)) return -1;
+        #endif
+        if (unlikely(pos >= tuple_size)) return 0;
+        *ppos = pos + 1;
+        #if CYTHON_ASSUME_SAFE_MACROS
+        next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        #else
+        next_item = PyTuple_GetItem(iter_obj, pos);
+        if (unlikely(!next_item)) return -1;
+        #endif
+        Py_INCREF(next_item);
+    } else if (PyList_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(list_size < 0)) return -1;
+        #endif
+        if (unlikely(pos >= list_size)) return 0;
+        *ppos = pos + 1;
+        next_item = __Pyx_PyList_GetItemRef(iter_obj, pos);
+        if (unlikely(!next_item)) return -1;
+    } else
+#endif
+    {
+        next_item = PyIter_Next(iter_obj);
+        if (unlikely(!next_item)) {
+            return __Pyx_IterFinish();
+        }
+    }
+    if (pitem) {
+        *pitem = next_item;
+    } else if (pkey && pvalue) {
+        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
+            return -1;
+    } else if (pkey) {
+        *pkey = next_item;
+    } else {
+        *pvalue = next_item;
+    }
+    return 1;
+}
+
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* TupleAndListFromArray */
+#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    Py_ssize_t i;
+    if (n <= 0) {
+        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    for (i = 0; i < n; i++) {
+        if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) {
+            Py_DECREF(res);
+            return NULL;
+        }
+        Py_INCREF(src[i]);
+    }
+    return res;
+}
+#elif CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple);
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\
+        !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS)
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length, length2;
+        int kind;
+        void *data1, *data2;
+        #if !CYTHON_COMPILING_IN_LIMITED_API
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        #endif
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(length < 0)) return -1;
+        #endif
+        length2 = __Pyx_PyUnicode_GET_LENGTH(s2);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(length2 < 0)) return -1;
+        #endif
+        if (length != length2) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    return (equals == Py_EQ);
+return_ne:
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames);
+    #if !CYTHON_ASSUME_SAFE_SIZE
+    if (unlikely(n == -1)) return NULL;
+    #endif
+    for (i = 0; i < n; i++)
+    {
+        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!namei)) return NULL;
+        #endif
+        if (s == namei) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i);
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!namei)) return NULL;
+        #endif
+        int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs;
+    PyObject *dict;
+#if !CYTHON_ASSUME_SAFE_SIZE
+    nkwargs = PyTuple_Size(kwnames);
+    if (unlikely(nkwargs < 0)) return NULL;
+#else
+    nkwargs = PyTuple_GET_SIZE(kwnames);
+#endif
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i<nkwargs; i++) {
+#if !CYTHON_ASSUME_SAFE_MACROS
+        PyObject *key = PyTuple_GetItem(kwnames, i);
+        if (!key) goto bad;
+#else
+        PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+#endif
+        if (unlikely(PyDict_SetItem(dict, key, kwvalues[i]) < 0))
+            goto bad;
+    }
+    return dict;
+bad:
+    Py_DECREF(dict);
+    return NULL;
+}
+#endif
+#endif
+
+/* UnpackUnboundCMethod */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) {
+    PyObject *result;
+    PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
+    if (unlikely(!selfless_args)) return NULL;
+    result = PyObject_Call(method, selfless_args, kwargs);
+    Py_DECREF(selfless_args);
+    return result;
+}
+#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) {
+        return _PyObject_Vectorcall
+            (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames);
+}
+#else
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) {
+    return
+#if PY_VERSION_HEX < 0x03090000
+    _PyObject_Vectorcall
+#else
+    PyObject_Vectorcall
+#endif
+        (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames);
+}
+#endif
+static PyMethodDef __Pyx_UnboundCMethod_Def = {
+     "CythonUnboundCMethod",
+     __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall),
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000
+     METH_VARARGS | METH_KEYWORDS,
+#else
+     METH_FASTCALL | METH_KEYWORDS,
+#endif
+     NULL
+};
+static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
+    PyObject *method, *result=NULL;
+    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
+    if (unlikely(!method))
+        return -1;
+    result = method;
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
+    {
+        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
+        target->func = descr->d_method->ml_meth;
+        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    } else
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+#else
+    if (PyCFunction_Check(method))
+#endif
+    {
+        PyObject *self;
+        int self_found;
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        self = PyObject_GetAttrString(method, "__self__");
+        if (!self) {
+            PyErr_Clear();
+        }
+#else
+        self = PyCFunction_GET_SELF(method);
+#endif
+        self_found = (self && self != Py_None);
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        Py_XDECREF(self);
+#endif
+        if (self_found) {
+            PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method);
+            if (unlikely(!unbound_method)) return -1;
+            Py_DECREF(method);
+            result = unbound_method;
+        }
+    }
+#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    if (unlikely(target->method)) {
+        Py_DECREF(result);
+    } else
+#endif
+    target->method = result;
+    return 0;
+}
+
+/* CallUnboundCMethod0 */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
+    if (likely(was_initialized == 2 && cfunc->func)) {
+        if (likely(cfunc->flag == METH_NOARGS))
+            return __Pyx_CallCFunction(cfunc, self, NULL);
+        if (likely(cfunc->flag == METH_FASTCALL))
+            return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0);
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL);
+        if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS)))
+            return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL);
+        if (cfunc->flag == METH_VARARGS)
+            return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple);
+        return __Pyx__CallUnboundCMethod0(cfunc, self);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    else if (unlikely(was_initialized == 1)) {
+        __Pyx_CachedCFunction tmp_cfunc = {
+#ifndef __cplusplus
+            0
+#endif
+        };
+        tmp_cfunc.type = cfunc->type;
+        tmp_cfunc.method_name = cfunc->method_name;
+        return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self);
+    }
+#endif
+    PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self);
+    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
+    return result;
+}
+#endif
+static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+    PyObject *result;
+    if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+    result = __Pyx_PyObject_CallOneArg(cfunc->method, self);
+    return result;
+}
+
+/* py_dict_items */
+static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) {
+    return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d);
+}
+
+/* py_dict_values */
+static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) {
+    return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d);
+}
+
+/* OwnedDictNext */
+#if CYTHON_AVOID_BORROWED_REFS
+static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) {
+    PyObject *next = NULL;
+    if (!*ppos) {
+        if (pvalue) {
+            PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p);
+            if (unlikely(!dictview)) goto bad;
+            *ppos = PyObject_GetIter(dictview);
+            Py_DECREF(dictview);
+        } else {
+            *ppos = PyObject_GetIter(p);
+        }
+        if (unlikely(!*ppos)) goto bad;
+    }
+    next = PyIter_Next(*ppos);
+    if (!next) {
+        if (PyErr_Occurred()) goto bad;
+        return 0;
+    }
+    if (pkey && pvalue) {
+        *pkey = __Pyx_PySequence_ITEM(next, 0);
+        if (unlikely(*pkey)) goto bad;
+        *pvalue = __Pyx_PySequence_ITEM(next, 1);
+        if (unlikely(*pvalue)) goto bad;
+        Py_DECREF(next);
+    } else if (pkey) {
+        *pkey = next;
+    } else {
+        assert(pvalue);
+        *pvalue = next;
+    }
+    return 1;
+  bad:
+    Py_XDECREF(next);
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
+    PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef");
+#else
+    PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef);
+#endif
+    if (pkey) *pkey = NULL;
+    if (pvalue) *pvalue = NULL;
+    return 0;
+}
+#else // !CYTHON_AVOID_BORROWED_REFS
+static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) {
+    int result = PyDict_Next(p, ppos, pkey, pvalue);
+    if (likely(result == 1)) {
+        if (pkey) Py_INCREF(*pkey);
+        if (pvalue) Py_INCREF(*pvalue);
+    }
+    return result;
+}
+#endif
+
+/* RaiseDoubleKeywords */
+static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+}
+
+/* CallUnboundCMethod2 */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
+    int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc);
+    if (likely(was_initialized == 2 && cfunc->func)) {
+        PyObject *args[2] = {arg1, arg2};
+        if (cfunc->flag == METH_FASTCALL) {
+            return __Pyx_CallCFunctionFast(cfunc, self, args, 2);
+        }
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    else if (unlikely(was_initialized == 1)) {
+        __Pyx_CachedCFunction tmp_cfunc = {
+#ifndef __cplusplus
+            0
+#endif
+        };
+        tmp_cfunc.type = cfunc->type;
+        tmp_cfunc.method_name = cfunc->method_name;
+        return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2);
+    }
+#endif
+    PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
+    __Pyx_CachedCFunction_SetFinishedInitializing(cfunc);
+    return result;
+}
+#endif
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
+    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
+        PyObject *result = NULL;
+        PyObject *args = PyTuple_New(2);
+        if (unlikely(!args)) return NULL;
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 0, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 1, arg2);
+        if (cfunc->flag & METH_KEYWORDS)
+            result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL);
+        else
+            result = __Pyx_CallCFunction(cfunc, self, args);
+        Py_DECREF(args);
+        return result;
+    }
+#endif
+    {
+        PyObject *args[4] = {NULL, self, arg1, arg2};
+        return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+    }
+}
+
+/* ParseKeywordsImpl */
+static int __Pyx_ValidateDuplicatePosArgs(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    const char* function_name)
+{
+    PyObject ** const *name = argnames;
+    while (name != first_kw_arg) {
+        PyObject *key = **name;
+        int found = PyDict_Contains(kwds, key);
+        if (unlikely(found)) {
+            if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key);
+            goto bad;
+        }
+        name++;
+    }
+    return 0;
+bad:
+    return -1;
+}
+#if CYTHON_USE_UNICODE_INTERNALS
+static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) {
+    int kind;
+    Py_ssize_t len = PyUnicode_GET_LENGTH(s1);
+    if (len != PyUnicode_GET_LENGTH(s2)) return 0;
+    kind = PyUnicode_KIND(s1);
+    if (kind != PyUnicode_KIND(s2)) return 0;
+    const void *data1 = PyUnicode_DATA(s1);
+    const void *data2 = PyUnicode_DATA(s2);
+    return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0);
+}
+#endif
+static int __Pyx_MatchKeywordArg_str(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    PyObject ** const *name;
+    #if CYTHON_USE_UNICODE_INTERNALS
+    Py_hash_t key_hash = ((PyASCIIObject*)key)->hash;
+    if (unlikely(key_hash == -1)) {
+        key_hash = PyObject_Hash(key);
+        if (unlikely(key_hash == -1))
+            goto bad;
+    }
+    #endif
+    name = first_kw_arg;
+    while (*name) {
+        PyObject *name_str = **name;
+        #if CYTHON_USE_UNICODE_INTERNALS
+        if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) {
+            *index_found = (size_t) (name - argnames);
+            return 1;
+        }
+        #else
+        #if CYTHON_ASSUME_SAFE_SIZE
+        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
+        #endif
+        {
+            int cmp = PyUnicode_Compare(name_str, key);
+            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+            if (cmp == 0) {
+                *index_found = (size_t) (name - argnames);
+                return 1;
+            }
+        }
+        #endif
+        name++;
+    }
+    name = argnames;
+    while (name != first_kw_arg) {
+        PyObject *name_str = **name;
+        #if CYTHON_USE_UNICODE_INTERNALS
+        if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) {
+            if (__Pyx_UnicodeKeywordsEqual(name_str, key))
+                goto arg_passed_twice;
+        }
+        #else
+        #if CYTHON_ASSUME_SAFE_SIZE
+        if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key))
+        #endif
+        {
+            if (unlikely(name_str == key)) goto arg_passed_twice;
+            int cmp = PyUnicode_Compare(name_str, key);
+            if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+            if (cmp == 0) goto arg_passed_twice;
+        }
+        #endif
+        name++;
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+bad:
+    return -1;
+}
+static int __Pyx_MatchKeywordArg_nostr(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    PyObject ** const *name;
+    if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type;
+    name = first_kw_arg;
+    while (*name) {
+        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
+        if (cmp == 1) {
+            *index_found = (size_t) (name - argnames);
+            return 1;
+        }
+        if (unlikely(cmp == -1)) goto bad;
+        name++;
+    }
+    name = argnames;
+    while (name != first_kw_arg) {
+        int cmp = PyObject_RichCompareBool(**name, key, Py_EQ);
+        if (unlikely(cmp != 0)) {
+            if (cmp == 1) goto arg_passed_twice;
+            else goto bad;
+        }
+        name++;
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+bad:
+    return -1;
+}
+static CYTHON_INLINE int __Pyx_MatchKeywordArg(
+    PyObject *key,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    size_t *index_found,
+    const char *function_name)
+{
+    return likely(PyUnicode_CheckExact(key)) ?
+        __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) :
+        __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name);
+}
+static void __Pyx_RejectUnknownKeyword(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject ** const *first_kw_arg,
+    const char *function_name)
+{
+    #if CYTHON_AVOID_BORROWED_REFS
+    PyObject *pos = NULL;
+    #else
+    Py_ssize_t pos = 0;
+    #endif
+    PyObject *key = NULL;
+    __Pyx_BEGIN_CRITICAL_SECTION(kwds);
+    while (
+        #if CYTHON_AVOID_BORROWED_REFS
+        __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL)
+        #else
+        PyDict_Next(kwds, &pos, &key, NULL)
+        #endif
+    ) {
+        PyObject** const *name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (!*name) {
+            size_t index_found = 0;
+            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
+            if (cmp != 1) {
+                if (cmp == 0) {
+                    PyErr_Format(PyExc_TypeError,
+                        "%s() got an unexpected keyword argument '%U'",
+                        function_name, key);
+                }
+                #if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(key);
+                #endif
+                break;
+            }
+        }
+        #if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(key);
+        #endif
+    }
+    __Pyx_END_CRITICAL_SECTION();
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(pos);
+    #endif
+    assert(PyErr_Occurred());
+}
+static int __Pyx_ParseKeywordDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    PyObject** const *name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    Py_ssize_t extracted = 0;
+#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
+    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
+#endif
+    name = first_kw_arg;
+    while (*name && num_kwargs > extracted) {
+        PyObject * key = **name;
+        PyObject *value;
+        int found = 0;
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+        found = PyDict_GetItemRef(kwds, key, &value);
+        #else
+        value = PyDict_GetItemWithError(kwds, key);
+        if (value) {
+            Py_INCREF(value);
+            found = 1;
+        } else {
+            if (unlikely(PyErr_Occurred())) goto bad;
+        }
+        #endif
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+            extracted++;
+        }
+        name++;
+    }
+    if (num_kwargs > extracted) {
+        if (ignore_unknown_kwargs) {
+            if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1))
+                goto bad;
+        } else {
+            __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name);
+            goto bad;
+        }
+    }
+    return 0;
+bad:
+    return -1;
+}
+static int __Pyx_ParseKeywordDictToDict(
+    PyObject *kwds,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject** const *name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    Py_ssize_t len;
+#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments)
+    if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1;
+#endif
+    if (PyDict_Update(kwds2, kwds) < 0) goto bad;
+    name = first_kw_arg;
+    while (*name) {
+        PyObject *key = **name;
+        PyObject *value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop))
+        int found = PyDict_Pop(kwds2, key, &value);
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+        }
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+        int found = PyDict_GetItemRef(kwds2, key, &value);
+        if (found) {
+            if (unlikely(found < 0)) goto bad;
+            values[name-argnames] = value;
+            if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad;
+        }
+#else
+    #if CYTHON_COMPILING_IN_CPYTHON
+        value = _PyDict_Pop(kwds2, key, kwds2);
+    #else
+        value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2);
+    #endif
+        if (value == kwds2) {
+            Py_DECREF(value);
+        } else {
+            if (unlikely(!value)) goto bad;
+            values[name-argnames] = value;
+        }
+#endif
+        name++;
+    }
+    len = PyDict_Size(kwds2);
+    if (len > 0) {
+        return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name);
+    } else if (unlikely(len == -1)) {
+        goto bad;
+    }
+    return 0;
+bad:
+    return -1;
+}
+static int __Pyx_ParseKeywordsTuple(
+    PyObject *kwds,
+    PyObject * const *kwvalues,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    PyObject *key = NULL;
+    PyObject** const * name;
+    PyObject** const *first_kw_arg = argnames + num_pos_args;
+    for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) {
+#if CYTHON_AVOID_BORROWED_REFS
+        key = __Pyx_PySequence_ITEM(kwds, pos);
+#else
+        key = __Pyx_PyTuple_GET_ITEM(kwds, pos);
+#endif
+#if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(!key)) goto bad;
+#endif
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            PyObject *value = kwvalues[pos];
+            values[name-argnames] = __Pyx_NewRef(value);
+        } else {
+            size_t index_found = 0;
+            int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name);
+            if (cmp == 1) {
+                PyObject *value = kwvalues[pos];
+                values[index_found] = __Pyx_NewRef(value);
+            } else {
+                if (unlikely(cmp == -1)) goto bad;
+                if (kwds2) {
+                    PyObject *value = kwvalues[pos];
+                    if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+                } else if (!ignore_unknown_kwargs) {
+                    goto invalid_keyword;
+                }
+            }
+        }
+        #if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(key);
+        key = NULL;
+        #endif
+    }
+    return 0;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    goto bad;
+bad:
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(key);
+    #endif
+    return -1;
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseKeywords(
+    PyObject *kwds,
+    PyObject * const *kwvalues,
+    PyObject ** const argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    Py_ssize_t num_kwargs,
+    const char* function_name,
+    int ignore_unknown_kwargs)
+{
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)))
+        return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
+    else if (kwds2)
+        return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name);
+    else
+        return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs);
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* ArgTypeTestFunc */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
+    PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode;
+    int from_annotation_subclass = 0;
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (!exact) {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    } else if (exact == 2) {
+        if (__Pyx_TypeCheck(obj, type)) {
+            from_annotation_subclass = 1;
+            extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately;
+        }
+    }
+    type_name = __Pyx_PyType_GetFullyQualifiedName(type);
+    obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")"
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        "%s%U"
+#endif
+        , name, type_name, obj_type_name
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        , (from_annotation_subclass ? ". " : ""), extra_info
+#endif
+        );
+#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+    if (exact == 2 && from_annotation_subclass) {
+        PyObject *res;
+        PyObject *vargs[2];
+        vargs[0] = PyErr_GetRaisedException();
+        vargs[1] = extra_info;
+        res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL);
+        Py_XDECREF(res);
+        PyErr_SetRaisedException(vargs[0]);
+    }
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_2_0
+#define __PYX_HAVE_RT_ImportType_3_2_0
+static PyTypeObject *__Pyx_ImportType_3_2_0(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_0 check_size)
+{
+    PyObject *result = 0;
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API)
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) )
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    if (size == 0) {
+        return (PyTypeObject *)result;
+    }
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_2_0 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_2_0 && (size_t)basicsize > size) {
+        if (PyErr_WarnFormat(NULL, 0,
+                "%.200s.%.200s size changed, may indicate binary incompatibility. "
+                "Expected %zd from C header, got %zd from PyObject",
+                module_name, class_name, size, basicsize) < 0) {
+            goto bad;
+        }
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* dict_setdefault */
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) {
+    PyObject* value;
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+    PyObject *args[] = {d, key, default_value};
+    value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL);
+#elif PY_VERSION_HEX >= 0x030d0000
+    PyDict_SetDefaultRef(d, key, default_value, &value);
+#else
+    value = PyDict_SetDefault(d, key, default_value);
+    if (unlikely(!value)) return NULL;
+    Py_INCREF(value);
+#endif
+    return value;
+}
+
+/* LimitedApiGetTypeDict */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static Py_ssize_t __Pyx_GetTypeDictOffset(void) {
+    PyObject *tp_dictoffset_o;
+    Py_ssize_t tp_dictoffset;
+    tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__");
+    if (unlikely(!tp_dictoffset_o)) return -1;
+    tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o);
+    Py_DECREF(tp_dictoffset_o);
+    if (unlikely(tp_dictoffset == 0)) {
+        PyErr_SetString(
+            PyExc_TypeError,
+            "'type' doesn't have a dictoffset");
+        return -1;
+    } else if (unlikely(tp_dictoffset < 0)) {
+        PyErr_SetString(
+            PyExc_TypeError,
+            "'type' has an unexpected negative dictoffset. "
+            "Please report this as Cython bug");
+        return -1;
+    }
+    return tp_dictoffset;
+}
+static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) {
+    static Py_ssize_t tp_dictoffset = 0;
+    if (unlikely(tp_dictoffset == 0)) {
+        tp_dictoffset = __Pyx_GetTypeDictOffset();
+        if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) {
+            tp_dictoffset = 0; // try again next time?
+            return NULL;
+        }
+    }
+    return *(PyObject**)((char*)tp + tp_dictoffset);
+}
+#endif
+
+/* SetItemOnTypeDict */
+static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) {
+    int result;
+    PyObject *tp_dict;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    tp_dict = __Pyx_GetTypeDict(tp);
+    if (unlikely(!tp_dict)) return -1;
+#else
+    tp_dict = tp->tp_dict;
+#endif
+    result = PyDict_SetItem(tp_dict, k, v);
+    if (likely(!result)) {
+        PyType_Modified(tp);
+        if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) {
+            PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name,  (PyObject *) tp, k, NULL);
+            if (!setNameResult) return -1;
+            Py_DECREF(setNameResult);
+        }
+    }
+    return result;
+}
+
+/* FixUpExtensionType */
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if __PYX_LIMITED_VERSION_HEX > 0x030900B1
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+    CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
+#else
+    const PyType_Slot *slot = spec->slots;
+    int changed = 0;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+#if !CYTHON_COMPILING_IN_CPYTHON
+        const
+#endif  // !CYTHON_COMPILING_IN_CPYTHON)
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_vectorcall_offset = memb->offset;
+                    changed = 1;
+                }
+#endif  // CYTHON_METH_FASTCALL
+#if !CYTHON_COMPILING_IN_PYPY
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
+                    Py_DECREF(descr);
+                    if (unlikely(set_item_result < 0)) {
+                        return -1;
+                    }
+                    changed = 1;
+                }
+#endif  // !CYTHON_COMPILING_IN_PYPY
+            }
+            memb++;
+        }
+    }
+#endif  // !CYTHON_COMPILING_IN_LIMITED_API
+#if !CYTHON_COMPILING_IN_PYPY
+    slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_getset)
+        slot++;
+    if (slot && slot->slot == Py_tp_getset) {
+        PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc;
+        while (getset && getset->name) {
+            if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) {
+                PyObject *descr = PyDescr_NewGetSet(type, getset);
+                if (unlikely(!descr))
+                    return -1;
+                #if CYTHON_COMPILING_IN_LIMITED_API
+                PyObject *pyname = PyUnicode_FromString(getset->name);
+                if (unlikely(!pyname)) {
+                    Py_DECREF(descr);
+                    return -1;
+                }
+                int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr);
+                Py_DECREF(pyname);
+                #else
+                CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
+                int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr);
+                #endif
+                Py_DECREF(descr);
+                if (unlikely(set_item_result < 0)) {
+                    return -1;
+                }
+                changed = 1;
+            }
+            ++getset;
+        }
+    }
+#else
+    CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict);
+#endif  // !CYTHON_COMPILING_IN_PYPY
+    if (changed)
+        PyType_Modified(type);
+#endif  // PY_VERSION_HEX > 0x030900B1
+    return 0;
+}
+
+/* AddModuleRef */
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+  static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) {
+      PyObject *module_dict = PyImport_GetModuleDict();
+      PyObject *m;
+      if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) {
+          return NULL;
+      }
+      if (m != NULL && PyModule_Check(m)) {
+          return m;
+      }
+      Py_XDECREF(m);
+      m = PyModule_NewObject(name);
+      if (m == NULL)
+          return NULL;
+      if (PyDict_CheckExact(module_dict)) {
+          PyObject *new_m;
+          (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m);
+          Py_DECREF(m);
+          return new_m;
+      } else {
+           if (PyObject_SetItem(module_dict, name, m) != 0) {
+                Py_DECREF(m);
+                return NULL;
+            }
+            return m;
+      }
+  }
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *py_name = PyUnicode_FromString(name);
+      if (!py_name) return NULL;
+      PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name);
+      Py_DECREF(py_name);
+      return module;
+  }
+#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+  #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name)
+#else
+  static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) {
+      PyObject *module = PyImport_AddModule(name);
+      Py_XINCREF(module);
+      return module;
+  }
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases);
+    if (result && metaclass) {
+        PyObject *old_tp = (PyObject*)Py_TYPE(result);
+    Py_INCREF((PyObject*)metaclass);
+#if __PYX_LIMITED_VERSION_HEX >= 0x03090000
+        Py_SET_TYPE(result, metaclass);
+#else
+        result->ob_type = metaclass;
+#endif
+        Py_DECREF(old_tp);
+    }
+    return result;
+}
+#else
+#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b)
+#endif
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t expected_basicsize) {
+    Py_ssize_t basicsize;
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (expected_basicsize == 0) {
+        return 0; // size is inherited, nothing useful to check
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+    if (unlikely(!py_basicsize)) return -1;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = NULL;
+    if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1;
+#else
+    basicsize = ((PyTypeObject*) cached_type)->tp_basicsize;
+#endif
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name;
+    int get_item_ref_result;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    py_object_name = PyUnicode_FromString(object_name);
+    if (!py_object_name) return NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) goto done;
+    abi_module_dict = PyModule_GetDict(abi_module);
+    if (!abi_module_dict) goto done;
+    get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type);
+    if (get_item_ref_result == 1) {
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    } else if (unlikely(get_item_ref_result == -1)) {
+        goto bad;
+    }
+    cached_type = __Pyx_PyType_FromMetaclass(
+        metaclass,
+        CYTHON_USE_MODULE_STATE ? module : abi_module,
+        spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type);
+    if (unlikely(new_cached_type != cached_type)) {
+        if (unlikely(!new_cached_type)) goto bad;
+        Py_DECREF(cached_type);
+        cached_type = new_cached_type;
+        if (__Pyx_VerifyCachedType(
+                cached_type,
+                object_name,
+                spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    } else {
+        Py_DECREF(new_cached_type);
+    }
+done:
+    Py_XDECREF(abi_module);
+    Py_DECREF(py_object_name);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+
+/* CommonTypesMetaclass */
+static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) {
+    return PyUnicode_FromString(__PYX_ABI_MODULE_NAME);
+}
+#if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) {
+    PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types");
+    return NULL;
+}
+static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) {
+    PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable");
+    return -1;
+}
+#endif
+static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = {
+    {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL},
+    {0, 0, 0, 0, 0}
+};
+static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = {
+    {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset},
+    #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call},
+    {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr},
+    #endif
+    {0, 0}
+};
+static PyType_Spec __pyx_CommonTypesMetaclass_spec = {
+    __PYX_TYPE_MODULE_PREFIX "_common_types_metatype",
+    0,
+    0,
+    Py_TPFLAGS_IMMUTABLETYPE |
+    Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT,
+    __pyx_CommonTypesMetaclass_slots
+};
+static int __pyx_CommonTypesMetaclass_init(PyObject *module) {
+    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
+    PyObject *bases = PyTuple_Pack(1, &PyType_Type);
+    if (unlikely(!bases)) {
+        return -1;
+    }
+    mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases);
+    Py_DECREF(bases);
+    if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+
+/* CallTypeTraverse */
+#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000)
+#else
+static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) {
+    #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000
+    if (__Pyx_get_runtime_version() < 0x03090000) return 0;
+    #endif
+    if (!always_call) {
+        PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*);
+        unsigned long flags = PyType_GetFlags(base);
+        if (flags & Py_TPFLAGS_HEAPTYPE) {
+            return 0;
+        }
+    }
+    Py_VISIT((PyObject*)Py_TYPE(o));
+    return 0;
+}
+#endif
+
+/* PyMethodNew */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000
+    {
+        PyObject *args[] = {func, self};
+        result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL);
+    }
+    #else
+    result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL);
+    #endif
+    return result;
+}
+#else
+static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) {
+    CYTHON_UNUSED_VAR(typ);
+    if (!self)
+        return __Pyx_NewRef(func);
+    return PyMethod_New(func, self);
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i;
+    #if CYTHON_AVOID_BORROWED_REFS
+    PyObject *pos;
+    #else
+    Py_ssize_t pos;
+    #endif
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    #if !CYTHON_ASSUME_SAFE_SIZE
+    Py_ssize_t nkw = PyDict_Size(kw);
+    if (unlikely(nkw == -1)) return NULL;
+    #else
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    #endif
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = 0;
+    i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) {
+        keys_are_strings &=
+        #if CYTHON_COMPILING_IN_LIMITED_API
+            PyType_GetFlags(Py_TYPE(key));
+        #else
+            Py_TYPE(key)->tp_flags;
+        #endif
+        #if !CYTHON_ASSUME_SAFE_MACROS
+        if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup;
+        #else
+        PyTuple_SET_ITEM(kwnames, i, key);
+        #endif
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(pos);
+    #endif
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    Py_ssize_t kw_size =
+        likely(kw == NULL) ?
+        0 :
+#if !CYTHON_ASSUME_SAFE_SIZE
+        PyDict_Size(kw);
+#else
+        PyDict_GET_SIZE(kw);
+#endif
+    if (kw_size == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+#if !CYTHON_ASSUME_SAFE_SIZE
+    else if (unlikely(kw_size == -1)) {
+        return NULL;
+    }
+#endif
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
+    if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) {
+        int result;
+        PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func);
+        if (unlikely(!newFunc)) {
+            PyErr_Clear(); // It's only an optimization, so don't throw an error
+            return 0;
+        }
+        result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc);
+        Py_DECREF(newFunc);
+        return result;
+    }
+    return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc);
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) {
+    if (PyMethod_Check(func)) {
+        func = PyMethod_GET_FUNCTION(func);
+    }
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op)
+{
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(closure);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_doc_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op)
+{
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#else
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject *result = NULL;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_name_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    PyObject *result;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    Py_INCREF(op->func_qualname);
+    result = op->func_qualname;
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+#endif
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->defaults_tuple;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = NULL;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_defaults_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->defaults_kwdict;
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_kwdefaults_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    __Pyx_END_CRITICAL_SECTION();
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) {
+    PyObject* result = op->func_annotations;
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(context);
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    result = __Pyx_CyFunction_get_annotations_locked(op);
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) {
+    int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+    if (is_coroutine) {
+        PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(is_coroutine_value)) {
+            return is_coroutine_value;
+        }
+ignore:
+        PyErr_Clear();
+    }
+    return __Pyx_PyBool_FromLong(is_coroutine);
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    PyObject *result;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    result = __Pyx_CyFunction_get_is_coroutine_value(op);
+    if (unlikely(!result))
+        return NULL;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    if (op->func_is_coroutine) {
+        Py_DECREF(result);
+        result = __Pyx_NewRef(op->func_is_coroutine);
+    } else {
+        op->func_is_coroutine = __Pyx_NewRef(result);
+    }
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
+    if (!py_name) return;
+    PyErr_Format(PyExc_TypeError,
+        "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+        py_name, message, size);
+    Py_DECREF(py_name);
+#else
+    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+        name, message, size);
+#endif
+}
+static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL);
+    if (!py_name) return;
+    PyErr_Format(PyExc_TypeError,
+        "%.200S() %s",
+        py_name, message);
+    Py_DECREF(py_name);
+#else
+    const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name;
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() %s",
+        name, message);
+#endif
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {"__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
+    {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0},
+    {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0},
+#else
+    {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0},
+    {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0},
+#endif
+    {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
+    {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#endif
+#if CYTHON_METH_FASTCALL
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+    {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    PyObject *result = NULL;
+    CYTHON_UNUSED_VAR(args);
+    __Pyx_BEGIN_CRITICAL_SECTION(m);
+    Py_INCREF(m->func_qualname);
+    result = m->func_qualname;
+    __Pyx_END_CRITICAL_SECTION();
+    return result;
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_dict = NULL;
+#endif
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func_dict);
+#elif PY_VERSION_HEX < 0x030d0000
+    _PyObject_ClearManagedDict((PyObject*)m);
+#else
+    PyObject_ClearManagedDict((PyObject*)m);
+#endif
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    Py_CLEAR(m->defaults);
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    {
+        int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg);
+        if (e) return e;
+    }
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func_dict);
+#else
+    {
+        int e =
+#if PY_VERSION_HEX < 0x030d0000
+            _PyObject_VisitManagedDict
+#else
+            PyObject_VisitManagedDict
+#endif
+                ((PyObject*)m, visit, arg);
+        if (e != 0) return e;
+    }
+#endif
+    __Pyx_VISIT_CONST(m->func_name);
+    __Pyx_VISIT_CONST(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    __Pyx_VISIT_CONST(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    Py_VISIT(m->defaults);
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+    PyObject *repr;
+    __Pyx_BEGIN_CRITICAL_SECTION(op);
+    repr = PyUnicode_FromFormat("<cyfunction %U at %p>",
+                                op->func_qualname, (void *)op);
+    __Pyx_END_CRITICAL_SECTION();
+    return repr;
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_SIZE
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+            __Pyx_CyFunction_raise_argument_count_error(
+                (__pyx_CyFunctionObject*)func,
+                "takes no arguments", size);
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_SIZE
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+            __Pyx_CyFunction_raise_argument_count_error(
+                (__pyx_CyFunctionObject*)func,
+                "takes exactly one argument", size);
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+    __Pyx_CyFunction_raise_type_error(
+        (__pyx_CyFunctionObject*)func, "takes no keyword arguments");
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_SIZE
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(argc < 0)) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            __Pyx_CyFunction_raise_type_error(
+                cyfunc, "needs an argument");
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) {
+        __Pyx_CyFunction_raise_type_error(
+            cyfunc, "takes no keyword arguments");
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        __Pyx_CyFunction_raise_argument_count_error(
+            cyfunc, "takes no arguments", nargs);
+        return NULL;
+    }
+    return meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        __Pyx_CyFunction_raise_argument_count_error(
+            cyfunc, "takes exactly one argument", nargs);
+        return NULL;
+    }
+    return meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+    PyObject *self;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunction meth = PyCFunction_GetFunction(cyfunc->func);
+    if (unlikely(!meth)) return NULL;
+#else
+    PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth;
+#endif
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+#if CYTHON_COMPILING_IN_LIMITED_API
+        self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func);
+        if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+#endif
+        break;
+    default:
+        return NULL;
+    }
+    #if PY_VERSION_HEX < 0x030e00A6
+    size_t nargs_value = (size_t) nargs;
+    #else
+    Py_ssize_t nargs_value = nargs;
+    #endif
+    return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames);
+}
+#endif
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if CYTHON_METH_FASTCALL
+#if defined(Py_TPFLAGS_HAVE_VECTORCALL)
+    Py_TPFLAGS_HAVE_VECTORCALL |
+#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+#endif // CYTHON_METH_FASTCALL
+#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API
+    Py_TPFLAGS_MANAGED_DICT |
+#endif
+    Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+static int __pyx_CyFunction_init(PyObject *module) {
+    __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module);
+    mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(
+        mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL);
+    if (unlikely(mstate->__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type);
+    if (unlikely(!m->defaults))
+        return NULL;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d0000
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* CLineInTraceback */
+#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000
+#define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o))
+#elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+#define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL);
+#else
+PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) {
+    PyObject **dict_ptr = _PyObject_GetDictPtr(o);
+    return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL;
+}
+#endif
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
+    PyObject *use_cline = NULL;
+    PyObject *ptype, *pvalue, *ptraceback;
+    PyObject *cython_runtime_dict;
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
+    if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+    cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, cython_runtime_dict,
+            __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False))
+    }
+    if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    Py_XDECREF(use_cline);
+    Py_XDECREF(cython_runtime_dict);
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) {
+    __Pyx_CachedCodeObjectType* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!code_cache->entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
+    if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = code_cache->entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) {
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
+    (void)__pyx__find_code_object;
+    return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss.
+#else
+    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count);
+    if (old_count < 0) {
+        __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
+        return NULL;
+    }
+#endif
+    __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line);
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_decr_acq_rel(&code_cache->accessor_count);
+#endif
+    return result;
+#endif
+}
+static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object)
+{
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = code_cache->entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            code_cache->entries = entries;
+            code_cache->max_count = 64;
+            code_cache->count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line);
+    if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) {
+        __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_INCREF(code_object);
+        Py_DECREF(tmp);
+        return;
+    }
+    if (code_cache->count == code_cache->max_count) {
+        int new_max = code_cache->max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        code_cache->entries = entries;
+        code_cache->max_count = new_max;
+    }
+    for (i=code_cache->count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    code_cache->count++;
+    Py_INCREF(code_object);
+}
+static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) {
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS
+    (void)__pyx__insert_code_object;
+    return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail.
+#else
+    struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache;
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_nonatomic_int_type expected = 0;
+    if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) {
+        return;
+    }
+#endif
+    __pyx__insert_code_object(code_cache, code_line, code_object);
+#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING
+    __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN);
+#endif
+#endif
+}
+
+/* AddTraceback */
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION)
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!code_object) {
+        code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+        if (unlikely(!code_object)) goto bad;
+        py_py_line = PyLong_FromLong(py_line);
+        if (unlikely(!py_py_line)) goto bad;
+        if (c_line) {
+            py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        } else {
+            py_funcname = PyUnicode_FromString(funcname);
+        }
+        if (unlikely(!py_funcname)) goto bad;
+        dict = PyDict_New();
+        if (unlikely(!dict)) goto bad;
+        {
+            PyObject *old_code_object = code_object;
+            code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+            Py_DECREF(old_code_object);
+        }
+        if (unlikely(!code_object)) goto bad;
+        __pyx_insert_code_object(c_line ? -c_line : py_line, code_object);
+    } else {
+        dict = PyDict_New();
+    }
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = NULL;
+    PyObject *py_funcname = NULL;
+    if (c_line) {
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        if (!py_funcname) goto bad;
+        funcname = PyUnicode_AsUTF8(py_funcname);
+        if (!funcname) goto bad;
+    }
+    py_code = PyCode_NewEmpty(filename, funcname, py_line);
+    Py_XDECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject *ptype, *pvalue, *ptraceback;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) {
+            /* If the code object creation fails, then we should clear the
+               fetched exception references and propagate the new exception */
+            Py_XDECREF(ptype);
+            Py_XDECREF(pvalue);
+            Py_XDECREF(ptraceback);
+            goto bad;
+        }
+        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_mstate_global->__pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+#endif
+
+/* CIntFromPyVerify */
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntFromPy */
+static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyLong_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
+                case 2:
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+        }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
+#else
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (int) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
+#endif
+        if ((sizeof(int) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+        } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        }
+    } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                case -2:
+                    if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+        }
+#endif
+        if ((sizeof(int) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+        } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+        }
+    }
+    {
+        int val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (int) -1;
+            assert(PyLong_CheckExact(v));
+        }
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
+                Py_DECREF(v);
+                return (int) -1;
+            }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (int) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (int) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((int) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((int) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
+#endif
+        if (unlikely(ret))
+            return (int) -1;
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000
+static __Pyx_TypeName
+__Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp)
+{
+    PyObject *module = NULL, *name = NULL, *result = NULL;
+    #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+    name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_mstate_global->__pyx_n_u_qualname);
+    #else
+    name = PyType_GetQualName(tp);
+    #endif
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad;
+    module = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_mstate_global->__pyx_n_u_module);
+    if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad;
+    if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) {
+        result = name;
+        name = NULL;
+        goto done;
+    }
+    result = PyUnicode_FromFormat("%U.%U", module, name);
+    if (unlikely(result == NULL)) goto bad;
+  done:
+    Py_XDECREF(name);
+    Py_XDECREF(module);
+    return result;
+  bad:
+    PyErr_Clear();
+    if (name) {
+        result = name;
+        name = NULL;
+    } else {
+        result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u_);
+    }
+    goto done;
+}
+#endif
+
+/* PyObjectVectorCallKwBuilder */
+#if CYTHON_VECTORCALL
+static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    (void)__Pyx_PyObject_FastCallDict;
+    if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1;
+    Py_INCREF(key);
+    args[n] = value;
+    return 0;
+}
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    (void)__Pyx_VectorcallBuilder_AddArgStr;
+    if (unlikely(!PyUnicode_Check(key))) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        return -1;
+    }
+    return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n);
+}
+static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) {
+    PyObject *pyKey = PyUnicode_FromString(key);
+    if (!pyKey) return -1;
+    return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n);
+}
+#else // CYTHON_VECTORCALL
+CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) {
+    if (unlikely(!PyUnicode_Check(key))) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        return -1;
+    }
+    return PyDict_SetItem(builder, key, value);
+}
+#endif
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#if !CYTHON_COMPILING_IN_PYPY
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyLong_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+#else
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL, *kwds = NULL;
+        PyObject *py_bytes = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        {
+            PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str };
+            if (!is_unsigned) {
+                kwds = __Pyx_MakeVectorcallBuilderKwds(1);
+                if (!kwds) goto limited_bad;
+                if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad;
+            }
+            result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds);
+        }
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (unlikely(!PyLong_Check(x))) {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_Long(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyLong_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+    if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
+                case 2:
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+        }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
+#else
+        {
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return (long) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
+#endif
+        if ((sizeof(long) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+        } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+        }
+    } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                case -2:
+                    if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+        }
+#endif
+        if ((sizeof(long) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+        } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+        }
+    }
+    {
+        long val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return (long) -1;
+            assert(PyLong_CheckExact(v));
+        }
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
+                Py_DECREF(v);
+                return (long) -1;
+            }
+            is_negative = result == 1;
+        }
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return (long) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+        val = (long) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= ((long) idigit) << bits;
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= ((long) idigit) << bits;
+        }
+        if (!is_unsigned) {
+            if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                goto raise_overflow;
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
+#endif
+        if (unlikely(ret))
+            return (long) -1;
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* FastTypeChecks */
+#if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
+static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    }
+}
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    n = PyTuple_GET_SIZE(tuple);
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+    for (i=0; i<n; i++) {
+        PyObject *t = PyTuple_GET_ITEM(tuple, i);
+        if (likely(PyExceptionClass_Check(t))) {
+            if (__Pyx_inner_PyErr_GivenExceptionMatches2(exc_type, NULL, t)) return 1;
+        } else {
+        }
+    }
+    return 0;
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) {
+    if (likely(err == exc_type)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        if (likely(PyExceptionClass_Check(exc_type))) {
+            return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type);
+        } else if (likely(PyTuple_Check(exc_type))) {
+            return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type);
+        } else {
+        }
+    }
+    return PyErr_GivenExceptionMatches(err, exc_type);
+}
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) {
+    assert(PyExceptionClass_Check(exc_type1));
+    assert(PyExceptionClass_Check(exc_type2));
+    if (likely(err == exc_type1 || err == exc_type2)) return 1;
+    if (likely(PyExceptionClass_Check(err))) {
+        return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2);
+    }
+    return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2));
+}
+#endif
+
+/* GetRuntimeVersion */
+#if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+void __Pyx_init_runtime_version(void) {
+    if (__Pyx_cached_runtime_version == 0) {
+        const char* rt_version = Py_GetVersion();
+        unsigned long version = 0;
+        unsigned long factor = 0x01000000UL;
+        unsigned int digit = 0;
+        int i = 0;
+        while (factor) {
+            while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+                digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+                ++i;
+            }
+            version += factor * digit;
+            if (rt_version[i] != '.')
+                break;
+            digit = 0;
+            factor >>= 8;
+            ++i;
+        }
+        __Pyx_cached_runtime_version = version;
+    }
+}
+#endif
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
+    return Py_Version & ~0xFFUL;
+#else
+    return __Pyx_cached_runtime_version;
+#endif
+}
+
+/* CheckBinaryVersion */
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+}
+
+/* NewCodeObj */
+#if CYTHON_COMPILING_IN_LIMITED_API
+    static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
+                                       PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                       PyObject *fv, PyObject *cell, PyObject* fn,
+                                       PyObject *name, int fline, PyObject *lnos) {
+        PyObject *exception_table = NULL;
+        PyObject *types_module=NULL, *code_type=NULL, *result=NULL;
+        #if __PYX_LIMITED_VERSION_HEX < 0x030b0000
+        PyObject *version_info;
+        PyObject *py_minor_version = NULL;
+        #endif
+        long minor_version = 0;
+        PyObject *type, *value, *traceback;
+        PyErr_Fetch(&type, &value, &traceback);
+        #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000
+        minor_version = 11;
+        #else
+        if (!(version_info = PySys_GetObject("version_info"))) goto end;
+        if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end;
+        minor_version = PyLong_AsLong(py_minor_version);
+        Py_DECREF(py_minor_version);
+        if (minor_version == -1 && PyErr_Occurred()) goto end;
+        #endif
+        if (!(types_module = PyImport_ImportModule("types"))) goto end;
+        if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end;
+        if (minor_version <= 7) {
+            (void)p;
+            result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else if (minor_version <= 10) {
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, fline, lnos, fv, cell);
+        } else {
+            if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end;
+            result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code,
+                          c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell);
+        }
+    end:
+        Py_XDECREF(code_type);
+        Py_XDECREF(exception_table);
+        Py_XDECREF(types_module);
+        if (type) {
+            PyErr_Restore(type, value, traceback);
+        }
+        return result;
+    }
+#elif PY_VERSION_HEX >= 0x030B0000
+  static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f,
+                                         PyObject *code, PyObject *c, PyObject* n, PyObject *v,
+                                         PyObject *fv, PyObject *cell, PyObject* fn,
+                                         PyObject *name, int fline, PyObject *lnos) {
+    PyCodeObject *result;
+    result =
+      #if PY_VERSION_HEX >= 0x030C0000
+        PyUnstable_Code_NewWithPosOnlyArgs
+      #else
+        PyCode_NewWithPosOnlyArgs
+      #endif
+        (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes);
+    #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1
+    if (likely(result))
+        result->_co_firsttraceable = 0;
+    #endif
+    return result;
+  }
+#elif !CYTHON_COMPILING_IN_PYPY
+  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+  #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+static PyObject* __Pyx_PyCode_New(
+        const __Pyx_PyCode_New_function_description descr,
+        PyObject * const *varnames,
+        PyObject *filename,
+        PyObject *funcname,
+        PyObject *line_table,
+        PyObject *tuple_dedup_map
+) {
+    PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL;
+    Py_ssize_t var_count = (Py_ssize_t) descr.nlocals;
+    PyObject *varnames_tuple = PyTuple_New(var_count);
+    if (unlikely(!varnames_tuple)) return NULL;
+    for (Py_ssize_t i=0; i < var_count; i++) {
+        Py_INCREF(varnames[i]);
+        if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done;
+    }
+    #if CYTHON_COMPILING_IN_LIMITED_API
+    varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple);
+    if (!varnames_tuple_dedup) {
+        if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done;
+        varnames_tuple_dedup = varnames_tuple;
+    }
+    #else
+    varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple);
+    if (unlikely(!varnames_tuple_dedup)) goto done;
+    #endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(varnames_tuple_dedup);
+    #endif
+    if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) {
+        Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table);
+        #if !CYTHON_ASSUME_SAFE_SIZE
+        if (unlikely(line_table_length == -1)) goto done;
+        #endif
+        Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL;
+        code_bytes = PyBytes_FromStringAndSize(NULL, code_len);
+        if (unlikely(!code_bytes)) goto done;
+        char* c_code_bytes = PyBytes_AsString(code_bytes);
+        if (unlikely(!c_code_bytes)) goto done;
+        memset(c_code_bytes, 0, (size_t) code_len);
+    }
+    code_obj = (PyObject*) __Pyx__PyCode_New(
+        (int) descr.argcount,
+        (int) descr.num_posonly_args,
+        (int) descr.num_kwonly_args,
+        (int) descr.nlocals,
+        0,
+        (int) descr.flags,
+        code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        varnames_tuple_dedup,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        __pyx_mstate_global->__pyx_empty_tuple,
+        filename,
+        funcname,
+        (int) descr.first_line,
+        (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes
+    );
+done:
+    Py_XDECREF(code_bytes);
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_XDECREF(varnames_tuple_dedup);
+    #endif
+    Py_DECREF(varnames_tuple);
+    return code_obj;
+}
+
+/* DecompressString */
+static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) {
+    PyObject *module, *decompress, *compressed_bytes, *decompressed;
+    const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib";
+    PyObject *methodname = PyUnicode_FromString("decompress");
+    if (unlikely(!methodname)) return NULL;
+    #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000
+    if (algo == 3) {
+        PyObject *fromlist = Py_BuildValue("[O]", methodname);
+        if (unlikely(!fromlist)) return NULL;
+        module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+    } else
+    #endif
+        module = PyImport_ImportModule(module_name);
+    if (unlikely(!module)) goto import_failed;
+    decompress = PyObject_GetAttr(module, methodname);
+    if (unlikely(!decompress)) goto import_failed;
+    {
+        #ifdef __cplusplus
+            char *memview_bytes = const_cast<char*>(s);
+        #else
+            #if defined(__clang__)
+              #pragma clang diagnostic push
+              #pragma clang diagnostic ignored "-Wcast-qual"
+            #elif !defined(__INTEL_COMPILER) && defined(__GNUC__)
+              #pragma GCC diagnostic push
+              #pragma GCC diagnostic ignored "-Wcast-qual"
+            #endif
+            char *memview_bytes = (char*) s;
+            #if defined(__clang__)
+              #pragma clang diagnostic pop
+            #elif !defined(__INTEL_COMPILER) && defined(__GNUC__)
+              #pragma GCC diagnostic pop
+            #endif
+        #endif
+        #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ)
+        int memview_flags = 0x100;
+        #else
+        int memview_flags = PyBUF_READ;
+        #endif
+        compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags);
+    }
+    if (unlikely(!compressed_bytes)) {
+        Py_DECREF(decompress);
+        goto bad;
+    }
+    decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL);
+    Py_DECREF(compressed_bytes);
+    Py_DECREF(decompress);
+    Py_DECREF(module);
+    Py_DECREF(methodname);
+    return decompressed;
+import_failed:
+    PyErr_Format(PyExc_ImportError,
+        "Failed to import '%.20s.decompress' - cannot initialise module strings. "
+        "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.",
+        module_name, algo);
+bad:
+    Py_XDECREF(module);
+    Py_DECREF(methodname);
+    return NULL;
+}
+
+#include <string.h>
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {
+        const char* result;
+        Py_ssize_t unicode_length;
+        CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        #if __PYX_LIMITED_VERSION_HEX < 0x030A0000
+        if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL;
+        #else
+        result = PyUnicode_AsUTF8AndSize(o, length);
+        #endif
+        #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        unicode_length = PyUnicode_GetLength(o);
+        if (unlikely(unicode_length < 0)) return NULL;
+        if (unlikely(unicode_length != *length)) {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
+        }
+        #endif
+        return result;
+    }
+#else
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+#endif
+}
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8
+    if (PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+    if (PyByteArray_Check(o)) {
+#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)))
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+#else
+        *length = PyByteArray_Size(o);
+        if (*length == -1) return NULL;
+        return PyByteArray_AsString(o);
+#endif
+    } else
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result));
+    if (PyLong_Check(result)) {
+        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
+            Py_DECREF(result);
+            return NULL;
+        }
+        __Pyx_DECREF_TypeName(result_type_name);
+        return result;
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")",
+                 result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  PyObject *res = NULL;
+  if (likely(PyLong_Check(x)))
+      return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  if (likely(m && m->nb_int)) {
+      res = m->nb_int(x);
+  }
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+      res = PyNumber_Long(x);
+  }
+#endif
+  if (likely(res)) {
+      if (unlikely(!PyLong_CheckExact(res))) {
+          return __Pyx_PyNumber_LongWrongResultType(res);
+      }
+  }
+  else if (!PyErr_Occurred()) {
+      PyErr_SetString(PyExc_TypeError,
+                      "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
+    } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyLong_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
+  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
+    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
+  } else {
+    Py_ssize_t ival;
+    PyObject *x;
+    x = PyNumber_Index(o);
+    if (!x) return -1;
+    ival = PyLong_AsLong(x);
+    Py_DECREF(x);
+    return ival;
+  }
+}
+static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) {
+    CYTHON_UNUSED_VAR(b);
+    return __Pyx_NewRef(Py_None);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return __Pyx_NewRef(b ? Py_True: Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) {
+    return PyLong_FromSize_t(ival);
+}
+
+
+/* MultiPhaseInitModuleState */
+#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE
+#ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+#if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000)
+  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1
+#else
+  #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0
+#endif
+#endif
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS
+#error "Module state with PEP489 requires atomics. Currently that's one of\
+ C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics"
+#endif
+#if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+#define __Pyx_ModuleStateLookup_Lock()
+#define __Pyx_ModuleStateLookup_Unlock()
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000
+static PyMutex __Pyx_ModuleStateLookup_mutex = {0};
+#define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(__cplusplus) && __cplusplus >= 201103L
+#include <mutex>
+static std::mutex __Pyx_ModuleStateLookup_mutex;
+#define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock()
+#define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock()
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__)
+#include <threads.h>
+static mtx_t __Pyx_ModuleStateLookup_mutex;
+static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT;
+static void __Pyx_ModuleStateLookup_initialize_mutex(void) {
+    mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain);
+}
+#define __Pyx_ModuleStateLookup_Lock()\
+  call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\
+  mtx_lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(HAVE_PTHREAD_H)
+#include <pthread.h>
+static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER;
+#define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex)
+#elif defined(_WIN32)
+#include <Windows.h>  // synchapi.h on its own doesn't work
+static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT;
+#define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
+#define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex)
+#else
+#error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\
+ Requires C standard >= C11, or C++ standard >= C++11,\
+ or pthreads, or the Windows 32 API, or Python >= 3.13."
+#endif
+typedef struct {
+    int64_t id;
+    PyObject *module;
+} __Pyx_InterpreterIdAndModule;
+typedef struct {
+    char interpreter_id_as_index;
+    Py_ssize_t count;
+    Py_ssize_t allocated;
+    __Pyx_InterpreterIdAndModule table[1];
+} __Pyx_ModuleStateLookupData;
+#define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0;
+#endif
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0;
+#else
+static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL;
+#endif
+static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound(
+        __Pyx_InterpreterIdAndModule* table,
+        Py_ssize_t count,
+        int64_t interpreterId) {
+    __Pyx_InterpreterIdAndModule* begin = table;
+    __Pyx_InterpreterIdAndModule* end = begin + count;
+    if (begin->id == interpreterId) {
+        return begin;
+    }
+    while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
+        __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2;
+        if (halfway->id == interpreterId) {
+            return halfway;
+        }
+        if (halfway->id < interpreterId) {
+            begin = halfway;
+        } else {
+            end = halfway;
+        }
+    }
+    for (; begin < end; ++begin) {
+        if (begin->id >= interpreterId) return begin;
+    }
+    return begin;
+}
+static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return NULL;
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
+    {
+        __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+        if (likely(data)) {
+            __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data);
+            if (likely(data == new_data)) {
+                goto read_finished;
+            }
+        }
+        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+        __Pyx_ModuleStateLookup_Lock();
+        __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter);
+        data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data);
+        __Pyx_ModuleStateLookup_Unlock();
+    }
+  read_finished:;
+#else
+    __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data;
+#endif
+    __Pyx_InterpreterIdAndModule* found = NULL;
+    if (unlikely(!data)) goto end;
+    if (data->interpreter_id_as_index) {
+        if (interpreter_id < data->count) {
+            found = data->table+interpreter_id;
+        }
+    } else {
+        found = __Pyx_State_FindModuleStateLookupTableLowerBound(
+            data->table, data->count, interpreter_id);
+    }
+  end:
+    {
+        PyObject *result=NULL;
+        if (found && found->id == interpreter_id) {
+            result = found->module;
+        }
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+        __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter);
+#endif
+        return result;
+    }
+}
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) {
+    while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0);
+}
+#else
+#define __Pyx_ModuleStateLookup_wait_until_no_readers()
+#endif
+static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) {
+    Py_ssize_t to_allocate = (*old_data)->allocated;
+    while (to_allocate <= interpreter_id) {
+        if (to_allocate == 0) to_allocate = 1;
+        else to_allocate *= 2;
+    }
+    __Pyx_ModuleStateLookupData *new_data = *old_data;
+    if (to_allocate != (*old_data)->allocated) {
+         new_data = (__Pyx_ModuleStateLookupData *)realloc(
+            *old_data,
+            sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
+        if (!new_data) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) {
+            new_data->table[i].id = i;
+            new_data->table[i].module = NULL;
+        }
+        new_data->allocated = to_allocate;
+    }
+    new_data->table[interpreter_id].module = module;
+    if (new_data->count < interpreter_id+1) {
+        new_data->count = interpreter_id+1;
+    }
+    *old_data = new_data;
+    return 0;
+}
+static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) {
+    __Pyx_InterpreterIdAndModule *read = data->table;
+    __Pyx_InterpreterIdAndModule *write = data->table;
+    __Pyx_InterpreterIdAndModule *end = read + data->count;
+    for (; read<end; ++read) {
+        if (read->module) {
+            write->id = read->id;
+            write->module = read->module;
+            ++write;
+        }
+    }
+    data->count = write - data->table;
+    for (; write<end; ++write) {
+        write->id = 0;
+        write->module = NULL;
+    }
+    data->interpreter_id_as_index = 0;
+}
+static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return -1;
+    int result = 0;
+    __Pyx_ModuleStateLookup_Lock();
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *)
+            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
+#else
+    __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data;
+#endif
+    __Pyx_ModuleStateLookupData *new_data = old_data;
+    if (!new_data) {
+        new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData));
+        if (!new_data) {
+            result = -1;
+            PyErr_NoMemory();
+            goto end;
+        }
+        new_data->allocated = 1;
+        new_data->interpreter_id_as_index = 1;
+    }
+    __Pyx_ModuleStateLookup_wait_until_no_readers();
+    if (new_data->interpreter_id_as_index) {
+        if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) {
+            result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id);
+            goto end;
+        }
+        __Pyx_State_ConvertFromInterpIdAsIndex(new_data);
+    }
+    {
+        Py_ssize_t insert_at = 0;
+        {
+            __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
+                new_data->table, new_data->count, interpreter_id);
+            assert(lower_bound);
+            insert_at = lower_bound - new_data->table;
+            if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) {
+                lower_bound->module = module;
+                goto end;  // already in table, nothing more to do
+            }
+        }
+        if (new_data->count+1 >= new_data->allocated) {
+            Py_ssize_t to_allocate = (new_data->count+1)*2;
+            new_data =
+                (__Pyx_ModuleStateLookupData*)realloc(
+                    new_data,
+                    sizeof(__Pyx_ModuleStateLookupData) +
+                    (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule));
+            if (!new_data) {
+                result = -1;
+                new_data = old_data;
+                PyErr_NoMemory();
+                goto end;
+            }
+            new_data->allocated = to_allocate;
+        }
+        ++new_data->count;
+        int64_t last_id = interpreter_id;
+        PyObject *last_module = module;
+        for (Py_ssize_t i=insert_at; i<new_data->count; ++i) {
+            int64_t current_id = new_data->table[i].id;
+            new_data->table[i].id = last_id;
+            last_id = current_id;
+            PyObject *current_module = new_data->table[i].module;
+            new_data->table[i].module = last_module;
+            last_module = current_module;
+        }
+    }
+  end:
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data);
+#else
+    __Pyx_ModuleStateLookup_data = new_data;
+#endif
+    __Pyx_ModuleStateLookup_Unlock();
+    return result;
+}
+static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) {
+    int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get());
+    if (interpreter_id == -1) return -1;
+    __Pyx_ModuleStateLookup_Lock();
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *)
+            __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0);
+#else
+    __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data;
+#endif
+    if (data->interpreter_id_as_index) {
+        if (interpreter_id < data->count) {
+            data->table[interpreter_id].module = NULL;
+        }
+        goto done;
+    }
+    {
+        __Pyx_ModuleStateLookup_wait_until_no_readers();
+        __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound(
+            data->table, data->count, interpreter_id);
+        if (!lower_bound) goto done;
+        if (lower_bound->id != interpreter_id) goto done;
+        __Pyx_InterpreterIdAndModule *end = data->table+data->count;
+        for (;lower_bound<end-1; ++lower_bound) {
+            lower_bound->id = (lower_bound+1)->id;
+            lower_bound->module = (lower_bound+1)->module;
+        }
+    }
+    --data->count;
+    if (data->count == 0) {
+        free(data);
+        data = NULL;
+    }
+  done:
+#if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE
+    __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data);
+#else
+    __Pyx_ModuleStateLookup_data = data;
+#endif
+    __Pyx_ModuleStateLookup_Unlock();
+    return 0;
+}
+#endif
+
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
+#endif /* Py_PYTHON_H */
diff --git a/cana/cboolean_node.pyx b/cana/cboolean_node.pyx
new file mode 100644
index 0000000..032eda4
--- /dev/null
+++ b/cana/cboolean_node.pyx
@@ -0,0 +1,144 @@
+# cython: language_level=3, boundscheck=False, wraparound=False, nonecheck=False
+"""Cython-accelerated helpers for ``cana.boolean_node``."""
+
+import cython
+
+from cpython.dict cimport PyDict_Size
+from cpython.list cimport (
+    PyList_Check,
+    PyList_GET_ITEM,
+    PyList_GET_SIZE,
+)
+from cpython.tuple cimport PyTuple_Check, PyTuple_GET_ITEM
+from cpython.sequence cimport PySequence_Size
+from cpython.exc cimport PyErr_Clear
+
+
+@cython.cfunc
+cdef inline Py_ssize_t _safe_sequence_size(object obj) except -1:
+    cdef Py_ssize_t size = PySequence_Size(obj)
+    if size < 0:
+        PyErr_Clear()
+        return 0
+    return size
+
+
+@cython.cfunc
+cdef inline double _sum_group_lengths(list f_theta) except? -1.0:
+    cdef Py_ssize_t len_f_theta = PyList_GET_SIZE(f_theta)
+    cdef Py_ssize_t i
+    cdef Py_ssize_t j
+    cdef Py_ssize_t group_len
+    cdef double total = 0.0
+    cdef object ts_obj
+    cdef object groups_obj
+    cdef object group_obj
+    cdef tuple ts
+    cdef list groups
+
+    if len_f_theta <= 0:
+        return 0.0
+
+    for i in range(len_f_theta):
+        ts_obj = <object>PyList_GET_ITEM(f_theta, i)
+        if PyTuple_Check(ts_obj):
+            ts = <tuple>ts_obj
+        else:
+            ts = tuple(ts_obj)
+        groups_obj = <object>PyTuple_GET_ITEM(ts, 1)
+        if groups_obj is None or not groups_obj:
+            continue
+        if not PyList_Check(groups_obj):
+            groups_obj = list(groups_obj)
+        groups = <list>groups_obj
+        for j in range(PyList_GET_SIZE(groups)):
+            group_obj = <object>PyList_GET_ITEM(groups, j)
+            if PyList_Check(group_obj):
+                group_len = PyList_GET_SIZE(group_obj)
+            else:
+                group_len = _safe_sequence_size(group_obj)
+            total += group_len
+
+    return total
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+cpdef double input_symmetry_mean_fast(dict ts_coverage, int k):
+    """Fast computation of :meth:`BooleanNode.input_symmetry_mean`.
+
+    Parameters
+    ----------
+    ts_coverage: dict
+        Mapping of LUT entries to the list of covering Two-Symbol schemata.
+    k: int
+        Input degree of the Boolean node.
+
+    Returns
+    -------
+    float
+        Mean number of permutable inputs over the LUT entries.
+    """
+    cdef double numerator = 0.0
+    cdef double inv_total_states
+    cdef double inv_len
+    cdef Py_ssize_t len_f_theta
+    cdef list f_theta
+
+    if ts_coverage is None:
+        return 0.0
+    if PyDict_Size(ts_coverage) == 0:
+        return 0.0
+    if k <= 0:
+        return 0.0
+
+    inv_total_states = 1.0 / (1 << k)
+
+    for f_theta in ts_coverage.values():
+        if not f_theta:
+            continue
+        if not PyList_Check(f_theta):
+            f_theta = list(f_theta)
+        f_theta = <list>f_theta
+        len_f_theta = PyList_GET_SIZE(f_theta)
+        if len_f_theta == 0:
+            continue
+        inv_len = 1.0 / len_f_theta
+        numerator += _sum_group_lengths(f_theta) * inv_len
+
+    return numerator * inv_total_states
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+@cython.nonecheck(False)
+cpdef double input_symmetry_mean_annigen_fast(dict ts_coverage):
+    """Fast computation of :meth:`BooleanNode.input_symmetry_mean_anni_gen`."""
+    cdef double numerator = 0.0
+    cdef double inv_len
+    cdef Py_ssize_t len_f_theta
+    cdef Py_ssize_t coverage_count = 0
+    cdef list f_theta
+
+    if ts_coverage is None:
+        return 0.0
+    if PyDict_Size(ts_coverage) == 0:
+        return 0.0
+
+    for f_theta in ts_coverage.values():
+        if not f_theta:
+            continue
+        if not PyList_Check(f_theta):
+            f_theta = list(f_theta)
+        f_theta = <list>f_theta
+        len_f_theta = PyList_GET_SIZE(f_theta)
+        if len_f_theta == 0:
+            continue
+        inv_len = 1.0 / len_f_theta
+        numerator += _sum_group_lengths(f_theta) * inv_len
+        coverage_count += 1
+
+    if coverage_count == 0:
+        return 0.0
+    return numerator / coverage_count
diff --git a/cana/datasets/bns/__init__.py b/cana/datasets/bns/__init__.py
new file mode 100644
index 0000000..d7eadcd
--- /dev/null
+++ b/cana/datasets/bns/__init__.py
@@ -0,0 +1 @@
+"""Network datasets bundled with CANA."""
diff --git a/cana/datasets/bools.py b/cana/datasets/bools.py
index 953fe8d..3e9df66 100644
--- a/cana/datasets/bools.py
+++ b/cana/datasets/bools.py
@@ -122,3 +122,12 @@ def RULE110():
     return BooleanNode.from_output_list(
         outputs=[0, 1, 1, 1, 0, 1, 1, 0], name="RULE 110"
     )
+
+def GP():
+    """Genetic Programming derivedd DCT rule.
+    See: Andre, D., Bennett III, F. H., and Koza, J. R. (1996). Discovery by genetic programming of a cellular automata rule that is better than any known rule for the majority classification problem. Genetic programming, 96:3–11.
+
+    """
+    return BooleanNode.from_output_list(
+        outputs="00000101000000000101010100000101000001010000000001010101000001010101010111111111010101011111111101010101111111110101010111111111", name="GP"
+    )
diff --git a/cana/datasets/cell_collective/__init__.py b/cana/datasets/cell_collective/__init__.py
new file mode 100644
index 0000000..9c6b98d
--- /dev/null
+++ b/cana/datasets/cell_collective/__init__.py
@@ -0,0 +1 @@
+"""Cell Collective datasets distributed with CANA."""
diff --git a/cana/drawing/plot_look_up_table.py b/cana/drawing/plot_look_up_table.py
index 3982700..f3286b5 100644
--- a/cana/drawing/plot_look_up_table.py
+++ b/cana/drawing/plot_look_up_table.py
@@ -81,9 +81,10 @@ def plot_look_up_table(n):
             x += cwidth + cxspace
 
         x += sepcxspace
-        r = Rectangle((x,y), width=cwidth, height=cwidth, facecolor='black' if (out==1) else 'white', edgecolor='black')
+        is_one = (out == 1) or (out == '1')
+        r = Rectangle((x,y), width=cwidth, height=cwidth, facecolor='black' if is_one else 'white', edgecolor='black')
         ax1.add_artist(Text(x-(sepcxspace/2)-(cxspace/2),y+cwidth/10*4, text=':', color='black', va='center', ha='center',fontsize=14,weight='bold',family='serif'))
-        ax1.add_artist(Text(x+(cwidth/2),y+cwidth/10*4, text=out, color='white' if (out==1) else 'black', va='center', ha='center',fontsize=14,family='serif'))
+        ax1.add_artist(Text(x+(cwidth/2),y+cwidth/10*4, text=str(out), color='white' if is_one else 'black', va='center', ha='center',fontsize=14,family='serif'))
         patches.append(r)
         xticks.append(x+cwidth/2)
         yticks.append(y+cwidth/2)
@@ -125,4 +126,138 @@ def plot_look_up_table(n):
     
     plt.close()
 
+def plot_annigen_look_up_table(n):
+    """
+    Plot annihilation and generation Look-Up Tables side by side.
+
+    For a given BooleanNode `n`, derive two nodes:
+    - annihilation: RULE & (NOT X_mid)
+    - generation: (NOT RULE) & (X_mid)
+    where X_mid is the middle input bit (index k//2), and plot their LUTs.
+
+    Parameters
+    ----------
+    n : BooleanNode
+        The BooleanNode used to derive annihilation and generation LUTs.
+
+    Returns
+    -------
+    None
+    """
+    # Guard for nodes without inputs
+    if not n.inputs:
+        return print('No inputs to plot')
+
+    # Init
+    k = n.k if n.k >= 1 else 1
+    inputs = n.inputs if not n.constant else [n.name]
+    inputlabels = [n.network.get_node_name(i)[0] if n.network is not None else i for i in inputs]
+
+    # Build annihilation and generation nodes from the LUT of n
+    lut = n.look_up_table()
+    mid_idx = k // 2
+    annihilation_outputs_lut = (
+        ((lut['Out:'] == '0') & (lut['In:'].str[mid_idx] == '1'))
+        .apply(lambda x: '1' if x else '0')
+        .tolist()
+    )
+    generation_outputs_lut = (
+        ((lut['Out:'] == '1') & (lut['In:'].str[mid_idx] == '0'))
+        .apply(lambda x: '1' if x else '0')
+        .tolist()
+    )
+
+    from cana.boolean_node import BooleanNode  # local import to avoid cycles at module init
+    anni = BooleanNode.from_output_list(annihilation_outputs_lut)
+    gen = BooleanNode.from_output_list(generation_outputs_lut)
+
+    LUT_A = anni.look_up_table().sort_index(ascending=False)
+    LUT_G = gen.look_up_table().sort_index(ascending=False)
+
+    # Drawing constants (match style of plot_look_up_table)
+    n_fs = LUT_A.shape[0]
+    cwidth = 60.
+    cxspace = 0
+    cyspace = 6
+    border = 1
+    sepcxspace = 21
+    dpi = 150.
+    # Increase horizontal spacing between subplots to avoid overlap
+    # Use at least one cell width plus separator as gap
+    top, right, bottom, left = 120, 25, 25, 60
+    hs = max(25, int(cwidth + sepcxspace))
+
+    axw = (k * (cwidth + cxspace)) + sepcxspace + (cwidth)
+    axh = (n_fs * (cwidth + cyspace) - cyspace)
+    fwidth = left + axw + hs + axw + right
+    fheight = bottom + axh + top
+
+    _axw = ((axw * 100) / fwidth) / 100
+    _axh = ((axh * 100) / fheight) / 100
+    _bottom = ((bottom * 100) / fheight) / 100
+    _left = ((left * 100) / fwidth) / 100
+    _hs = ((hs * 100) / fwidth) / 100
+
+    fig = plt.figure(figsize=(fwidth / dpi, fheight / dpi), facecolor='w', dpi=dpi)
+    axA = fig.add_axes((_left, _bottom, _axw, _axh), aspect=1, label='LUT-ANNI')
+    axG = fig.add_axes((_left + _axw + _hs, _bottom, _axw, _axh), aspect=1, label='LUT-GEN')
+
+    def _draw_lut(ax, LUT, title):
+        yticks = []
+        patches = []
+        x, y = 0., 0.
+        for _, r in LUT.iterrows():
+            ins = str(r['In:'])
+            out = r['Out:']
+            x = 0.
+            xticks = []
+            for ch in ins:
+                if ch == '0':
+                    facecolor = 'white'
+                    textcolor = 'black'
+                else:  # '1'
+                    facecolor = 'black'
+                    textcolor = 'white'
+                ax.add_artist(Text(x + cwidth/2, y + cwidth/10*4, text=ch, color=textcolor,
+                                   va='center', ha='center', fontsize=14, family='serif'))
+                patches.append(Rectangle((x, y), width=cwidth, height=cwidth, facecolor=facecolor, edgecolor='black'))
+                xticks.append(x + cwidth/2)
+                x += cwidth + cxspace
+
+            x += sepcxspace
+            is_one = (out == 1) or (out == '1')
+            patches.append(Rectangle((x, y), width=cwidth, height=cwidth, facecolor='black' if is_one else 'white', edgecolor='black'))
+            ax.add_artist(Text(x - (sepcxspace/2) - (cxspace/2), y + cwidth/10*4, text=':', color='black',
+                               va='center', ha='center', fontsize=14, weight='bold', family='serif'))
+            ax.add_artist(Text(x + (cwidth/2), y + cwidth/10*4, text=str(out), color='white' if is_one else 'black',
+                               va='center', ha='center', fontsize=14, family='serif'))
+            xticks.append(x + cwidth/2)
+            yticks.append(y + cwidth/2)
+            y += cwidth + cyspace
+
+        ax.add_collection(PatchCollection(patches, match_original=True))
+        ax.set_yticks(yticks)
+        ax.set_yticklabels([rf"$f_{{{i+1}}}$" for i in range(n_fs)[::-1]], fontsize=14)
+        ax.set_xticks(xticks)
+        ax.set_xticklabels(inputlabels + [f'{n.name}'], rotation=90, fontsize=14)
+        ax.set_title(str(title), fontsize=12, pad=8)
+        ax.xaxis.tick_top()
+        ax.tick_params(which='major', pad=7)
+        for tic in ax.xaxis.get_major_ticks():
+            tic.tick1On = tic.tick2On = False
+        for tic in ax.yaxis.get_major_ticks():
+            tic.tick1On = tic.tick2On = False
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['bottom'].set_visible(False)
+        ax.spines['left'].set_visible(False)
+        ax.set_xlim(-border, axw + border)
+        ax.set_ylim(-border, axh + border)
+
+    _draw_lut(axA, LUT_A, 'Annihilation')
+    _draw_lut(axG, LUT_G, 'Generation')
+
+    display(fig)
+    plt.close()
+
     
\ No newline at end of file
diff --git a/cana/drawing/schema_vis.py b/cana/drawing/schema_vis.py
index 82fa142..f88722e 100644
--- a/cana/drawing/schema_vis.py
+++ b/cana/drawing/schema_vis.py
@@ -5,6 +5,7 @@
 from matplotlib.collections import PatchCollection
 from matplotlib.patches import Circle, Rectangle, RegularPolygon
 from matplotlib.text import Text
+from cana.boolean_node import BooleanNode
 
 
 def plot_schemata(n, plotTS=True):
@@ -321,3 +322,354 @@ def plot_schemata(n, plotTS=True):
     # FileName
     filename = n.name.replace("/", "_")
     filename = filename.replace(",", "_")
+
+def plot_anni_gen_schemata(n, plotTS=True):
+    # Init values from BooleanNode
+    k = n.k if n.k >= 1 else 1
+    outputs = np.array(n.outputs)
+
+    if "?" in outputs:  # check if there are any '?' in the output.
+        raise ValueError("Error (plot_schemata()): The output contains '?'")
+    if np.all(outputs[0] == outputs):
+        return False
+    inputs = n.inputs if not n.constant else [n.name]
+    inputlabels = [
+        n.network.get_node_name(i)[0] if n.network is not None else i for i in inputs
+    ]
+
+    # get annihilation and generation nodes and their ts and pi
+    lut = n.look_up_table()
+    # pick middle input index dynamically for any k
+    mid_idx = k // 2
+    annihilation_outputs_lut = (
+        # RULE & (NOT X_mid): result is 1 for rules that annihilate
+        ((lut["Out:"] == "0") & (lut["In:"].str[mid_idx] == "1"))
+        .apply(lambda x: "1" if x else "0")
+        .tolist()
+    )
+    annihilation = BooleanNode.from_output_list(annihilation_outputs_lut)
+    generation_outputs = (
+        # (NOT RULE) & (X_mid): result is 1 for rules that generate
+        ((lut["Out:"] == "1") & (lut["In:"].str[mid_idx] == "0"))
+        .apply(lambda x: "1" if x else "0")
+        .tolist()
+    )
+    generation = BooleanNode.from_output_list(generation_outputs)
+
+    if not plotTS:
+        generation._check_compute_canalization_variables(prime_implicants=True)
+        annihilation._check_compute_canalization_variables(prime_implicants=True)
+    else:
+        annihilation._check_compute_canalization_variables(two_symbols=True)
+        generation._check_compute_canalization_variables(two_symbols=True)
+        tsas = annihilation._two_symbols[1]
+        tsgs = generation._two_symbols[1]
+        n_ts = sum(len(tss) for tss in [tsas, tsgs])
+
+    pias = annihilation._prime_implicants.get("1", [])
+    pigs = generation._prime_implicants.get("1", [])
+
+    # Count number of PI and TS
+    n_pi = sum(len(pis) for pis in [pias, pigs])
+    # Schemata Cell Width and spacing
+    cwidth = 60.0
+    cxspace = 0
+    cyspace = 6
+    border = 1
+    sepcxspace = 21
+    sepcyspace = 15
+    dpi = 150.0
+    # Margins
+    top, right, bottom, left, hs = 160, 25, 25, 60, 60
+    # Axes Width & Height
+    ax1width = (k * (cwidth + cxspace)) + sepcxspace + (cwidth)
+    ax1height = n_pi * (cwidth + cyspace) + sepcyspace - cyspace
+    ax2width = (k * (cwidth + cxspace)) + sepcxspace + (cwidth)
+    if not plotTS:
+        ax2height = ax1height
+    else:
+        ax2height = n_ts * (cwidth + cyspace) + sepcyspace - cyspace
+    # Figure Width & Height
+    fwidth = left + ax1width + hs + ax2width + right
+    fheight = bottom + max(ax1height, ax2height) + top
+    # Percentages for Axes location
+    _ax1w = ((ax1width * 100) / fwidth) / 100
+    _ax2w = ((ax2width * 100) / fwidth) / 100
+    _ax1h = ((ax1height * 100) / fheight) / 100
+    # _ax2h = ((ax2height * 100) / fheight) / 100 # not used, but here for completeness
+    _bottom = ((bottom * 100) / fheight) / 100
+    _left = ((left * 100) / fwidth) / 100
+    _hs = ((hs * 100) / fwidth) / 100
+    # Init Figure
+    fig = plt.figure(figsize=(fwidth / dpi, fheight / dpi), facecolor="w", dpi=dpi)
+    ax1 = fig.add_axes((_left, _bottom, _ax1w, _ax1h), aspect=1, label="PI")
+    ax2 = fig.add_axes(
+        (_left + _ax1w + _hs, _bottom, _ax2w, _ax1h), aspect=1, label="TS"
+    )
+
+    # PI Plot #
+
+    yticks = []
+    patches = []
+    x, y = 0.0, 0.0
+    # ensure xticks exists even if there are no PI schemata
+    xticks = []
+
+    for out, pis in zip([1, 0], [pigs, pias]):
+        for pi in pis:
+            x = 0.0
+            xticks = []
+            for input in pi:
+                if input == "0":
+                    facecolor = "white"
+                    textcolor = "black"
+                elif input == "1":
+                    facecolor = "black"
+                    textcolor = "white"
+                elif input == "#":
+                    facecolor = "#cccccc"
+                    textcolor = "black"
+                text = "%s" % (input) if (input != "2") else "#"
+                ax1.add_artist(
+                    Text(
+                        x + cwidth / 2,
+                        y + cwidth / 10 * 4,
+                        text=text,
+                        color=textcolor,
+                        va="center",
+                        ha="center",
+                        fontsize=14,
+                        family="serif",
+                    )
+                )
+                r = Rectangle(
+                    (x, y),
+                    width=cwidth,
+                    height=cwidth,
+                    facecolor=facecolor,
+                    edgecolor="black",
+                )
+                patches.append(r)
+                xticks.append(x + cwidth / 2)
+                x += cwidth + cxspace
+
+            x += sepcxspace
+            r = Rectangle(
+                (x, y),
+                width=cwidth,
+                height=cwidth,
+                facecolor="black" if (out == 1) else "white",
+                edgecolor="black",
+            )
+            ax1.add_artist(
+                Text(
+                    x - (sepcxspace / 2) - (cxspace / 2),
+                    y + cwidth / 10 * 4,
+                    text=":",
+                    color="black",
+                    va="center",
+                    ha="center",
+                    fontsize=14,
+                    weight="bold",
+                    family="serif",
+                )
+            )
+            ax1.add_artist(
+                Text(
+                    x + (cwidth / 2),
+                    y + cwidth / 10 * 4,
+                    text=out,
+                    color="white" if (out == 1) else "black",
+                    va="center",
+                    ha="center",
+                    fontsize=14,
+                    family="serif",
+                )
+            )
+            patches.append(r)
+            xticks.append(x + cwidth / 2)
+            yticks.append(y + cwidth / 2)
+            y += cwidth + cyspace
+        y += sepcyspace
+
+    ax1.add_collection(PatchCollection(patches, match_original=True))
+    #
+    ax1.set_yticks(yticks)
+    ax1.set_yticklabels(
+        [r"$f^{'}_{%d}$" % (i + 1) for i in range(n_pi)[::-1]], fontsize=14
+    )
+    # default xticks when no schemata drawn
+    if not xticks:
+        xticks = [i * (cwidth + cxspace) + (cwidth / 2) for i in range(k)]
+        xticks.append(k * (cwidth + cxspace) + sepcxspace + (cwidth / 2))
+    ax1.set_xticks(xticks)
+    ax1.set_xticklabels(inputlabels + ["%s" % (n.name)], rotation=90, fontsize=14)
+    #
+    ax1.xaxis.tick_top()
+    # Remove Tick
+    ax1.tick_params(which="major", pad=7)
+    for tic in ax1.xaxis.get_major_ticks():
+        tic.tick1On = tic.tick2On = False
+    for tic in ax1.yaxis.get_major_ticks():
+        tic.tick1On = tic.tick2On = False
+    # Remove Border
+    ax1.spines["top"].set_visible(False)
+    ax1.spines["right"].set_visible(False)
+    ax1.spines["bottom"].set_visible(False)
+    ax1.spines["left"].set_visible(False)
+    # Limits
+    ax1.set_xlim(-border, ax1width + border)
+    ax1.set_ylim(-border, ax1height + border)
+    # ax1.invert_yaxis()
+
+    # TS #
+    if not plotTS:
+        return
+
+    t = 0
+    x, y = 0.0, 0.0
+    yticks = []
+    boxes, symbols = [], []
+    # ensure xticks exists even if there are no TS schemata
+    xticks = []
+    #
+    tssymbols = [
+        Circle((0, 0), radius=5, facecolor="white", edgecolor="black"),
+        RegularPolygon(
+            (0, 0),
+            numVertices=3,
+            radius=5,
+            orientation=0,
+            facecolor="white",
+            edgecolor="black",
+        ),
+    ]
+
+    for out, tss in zip([1, 0], [tsgs, tsas]):
+        for ts, pss, _ in tss:
+            x = 0.0
+            xticks = []
+            for i, input in enumerate(ts):
+                if input == "0":
+                    facecolor = "white"
+                    textcolor = "black"
+                elif input == "1":
+                    facecolor = "black"
+                    textcolor = "white"
+                elif input == "2":
+                    facecolor = "#cccccc"
+                    textcolor = "black"
+
+                if len(pss):
+                    # TODO: If there are several symbols in the same input position, place them side-by-side
+                    iinpss = [j for j, ps in enumerate(pss) if i in ps]
+                    xpos = np.linspace(x, x + cwidth, len(iinpss) + 2)
+                    for z, j in enumerate(iinpss, start=1):
+                        s = copy(tssymbols[j])
+                        s.xy = (xpos[z], y + cwidth * 0.8)
+                        s.center = xpos[z], y + cwidth * 0.8  # A hack for circles only
+                        s.set_edgecolor("#a6a6a6" if (input == "1") else "black")
+                        symbols.append(s)
+                        # commented out 10/13/22: after matplotlib update, causes two symbols to be under other artists
+                        # ax2.add_patch(s)
+
+                text = "%s" % (input) if (input != "2") else "#"
+                ax2.add_artist(
+                    Text(
+                        x + cwidth / 2,
+                        y + cwidth / 10 * 4,
+                        text=text,
+                        color=textcolor,
+                        va="center",
+                        ha="center",
+                        fontsize=14,
+                        family="serif",
+                    )
+                )
+                r = Rectangle(
+                    (x, y),
+                    width=cwidth,
+                    height=cwidth,
+                    facecolor=facecolor,
+                    edgecolor="#4c4c4c",
+                    zorder=2,
+                )
+                boxes.append(r)
+                xticks.append(x + cwidth / 2)
+                x += cwidth + cxspace
+
+            x += sepcxspace
+            r = Rectangle(
+                (x, y),
+                width=cwidth,
+                height=cwidth,
+                facecolor="black" if (out == 1) else "white",
+                edgecolor="#4c4c4c",
+            )
+            ax2.add_artist(
+                Text(
+                    x - (sepcxspace / 2) - (cxspace / 2),
+                    y + cwidth / 2,
+                    text=":",
+                    color="black",
+                    va="center",
+                    ha="center",
+                    fontsize=14,
+                    weight="bold",
+                    family="serif",
+                )
+            )
+            ax2.add_artist(
+                Text(
+                    x + (cwidth / 2),
+                    y + cwidth / 10 * 4,
+                    text=out,
+                    color="white" if (out == 1) else "black",
+                    va="center",
+                    ha="center",
+                    fontsize=14,
+                    family="serif",
+                )
+            )
+            boxes.append(r)
+            xticks.append(x + cwidth / 2)
+            yticks.append(y + cwidth / 2)
+            y += cwidth + cyspace
+            t += 1
+        y += sepcyspace
+
+    if len(boxes):
+        ax2.add_collection(PatchCollection(boxes, match_original=True))
+    if len(symbols):
+        ax2.add_collection(PatchCollection(symbols, match_original=True))
+    #
+    ax2.set_yticks(yticks)
+    ax2.set_yticklabels(
+        [r"$f^{''}_{%d}$" % (i + 1) for i in range(n_ts)[::-1]], fontsize=14
+    )
+    # default xticks when no schemata drawn
+    if not xticks:
+        xticks = [i * (cwidth + cxspace) + (cwidth / 2) for i in range(k)]
+        xticks.append(k * (cwidth + cxspace) + sepcxspace + (cwidth / 2))
+    ax2.set_xticks(xticks)
+    ax2.set_xticklabels(inputlabels + ["%s" % (n.name)], rotation=90, fontsize=14)
+    #
+    ax2.xaxis.tick_top()
+    # Remove Tick
+    ax2.tick_params(which="major", pad=7)
+    for tic in ax2.xaxis.get_major_ticks():
+        tic.tick1On = tic.tick2On = False
+    for tic in ax2.yaxis.get_major_ticks():
+        tic.tick1On = tic.tick2On = False
+    # Remove Border
+    ax2.spines["top"].set_visible(False)
+    ax2.spines["right"].set_visible(False)
+    ax2.spines["bottom"].set_visible(False)
+    ax2.spines["left"].set_visible(False)
+    # Limits
+    ax2.set_xlim(-border, ax2width + border)
+    ax2.set_ylim(-border, ax2height + border)
+
+    # FileName
+    filename = n.name.replace("/", "_")
+    filename = filename.replace(",", "_")
diff --git a/cana/utils.py b/cana/utils.py
index 79fa0de..5c1d587 100644
--- a/cana/utils.py
+++ b/cana/utils.py
@@ -329,7 +329,7 @@ def input_monotone(outputs, input_idx, activation=1):
         return all(monotone_configs)
 
 
-def fill_out_lut(partial_lut, verbose=False):
+def fill_out_lut(partial_lut: list, fill_clashes: bool = False, verbose: bool =False)->list:
     """
     Fill out a partial LUT with missing entries.
 
@@ -337,9 +337,6 @@ def fill_out_lut(partial_lut, verbose=False):
         partial_lut (list) : A list of tuples where each tuple is a pair of a binary string and a value.
         fill_missing_output (bool) : If True, missing output values are filled with random 0 or 1. If False, missing output values are filled with '?'.
 
-
-
-
     Returns:
         (list) : A list of tuples where each tuple is a pair of a binary string and a value.
 
@@ -348,7 +345,6 @@ def fill_out_lut(partial_lut, verbose=False):
         [('00', 0), ('01', 0), ('10', 1), ('11', 1)]
 
     # TODO: [SRI] generate LUT from two symbol schemata, with a specified ratio of wildcard symbols
-    # TODO: [SRI] use examples COSA rule, GKL rule where you fill up LUT based on the annihilation inputs and see if it matches with the rules plus bias.
     """
 
     # Check if all the input entries of the partial LUT are of the same length.
@@ -384,12 +380,21 @@ def fill_out_lut(partial_lut, verbose=False):
                         + str(table[i][j])
                         + output_list_permutations[i][missing_data_indices[j] + 1 :]
                     )
-            del all_states[entry[0]]
+            if entry[0] in all_states:
+                del all_states[entry[0]]
 
             for perm in output_list_permutations:
                 if perm in all_states and all_states[perm] != entry[1]:
-                    print("Clashing output values for entry:", perm)
-                    all_states[perm] = "!"
+                    if verbose:
+                        print("Clashing output values for entry:", perm)
+                    if fill_clashes is False:
+                        all_states[perm] = "!"
+                    elif fill_clashes is True:
+                        all_states[perm] = entry[1]
+                    else:
+                        raise ValueError(
+                            "fill_clashes must be either True or False. Default is False."
+                        )
                 else:
                     all_states[perm] = entry[1]
 
diff --git a/setup.py b/setup.py
index 44e9e31..37339aa 100644
--- a/setup.py
+++ b/setup.py
@@ -12,6 +12,7 @@ def readme():
 # ext_modules = ["cana/cutils.pyx", "cana/canalization/cboolean_canalization.pyx"]
 extensions = [
     Extension("cana.cutils", ["cana/cutils.c"]),
+    Extension("cana.cboolean_node", ["cana/cboolean_node.c"]),
     Extension(
         "cana.canalization.cboolean_canalization",
         ["cana/canalization/cboolean_canalization.c"],
@@ -42,10 +43,10 @@ def readme():
     license="MIT",
     packages=find_packages(),
     package_data={
-        "datasets": [
-            "cana.datasets/*.txt",
-            "cana.datasets/bns/*.cnet",
-            "cana.datasets/cell_collective/*.txt",
+        "cana.datasets": [
+            "*.txt",
+            "bns/*.cnet",
+            "cell_collective/*.txt",
         ],
     },
     install_requires=[
diff --git a/tests/helper.py b/tests/helper.py
new file mode 100644
index 0000000..396e0dc
--- /dev/null
+++ b/tests/helper.py
@@ -0,0 +1,129 @@
+# helper functions for testing apparatus
+import math
+import random
+from itertools import permutations, product
+
+from cana.boolean_node import BooleanNode
+from cana.datasets.bio import load_all_cell_collective_models
+
+
+def randNode(k):
+    """Create a BooleaNode with random function at a given $k$"""
+    func = [random.randint(0, 1) for i in range(2**k)]
+    return BooleanNode(k=k, inputs=list(range(k)), outputs=func)
+
+
+def reorderTwoSymbolOutput(tss):
+    """Convert a list of two-symbol schemata to a set of two-symbol schemata with unique orderings for equality testing.
+
+    arguments:
+    tss -- two-symbol schemata list, [ (string, [[]], [[]]) ]
+    """
+    tssNew = set()
+    for ts in tss:
+        symGroups = ts[1]
+        schemata = list(ts[0])
+        for sg in symGroups:
+            sgNew = sorted(sg)
+            symsInSg = sorted([(i, schemata[i]) for i in sgNew], key=lambda x: x[1])
+            for i, sym in zip(sgNew, [i[1] for i in symsInSg]):
+                schemata[i] = sym
+        tssNew.add(
+            ("".join(schemata), frozenset(frozenset(i) for i in ts[1]), frozenset())
+        )  # WARNING: ignoring same-symbol symmetry for now
+    return tssNew
+
+
+def expandTs(ts):
+    """Expand a two-symbol schemata to the set of all schema (with don't cares) it encodes"""
+    # expand ts
+    tss = [i[0] for i in ts]
+    perms = [i[1] for i in ts]
+    obsSet = set()
+    # for each schema and its symmetries
+    for t, g in zip(tss, perms):
+        if isinstance(t, str):
+            t = list(t)
+        # for each subset of indices that can be permuted
+        x = []
+        for idxs in g:
+            # produce all permutations of those indices
+            x.append([(idxs, i) for i in permutations([t[j] for j in idxs], len(idxs))])
+        # get cross-product of groups
+        cxs = list(product(*x))
+        # can apply each sequence in each item of cross product
+        for seq in cxs:
+            tPerm = t.copy()
+            for p in seq:
+                for i, j in zip(p[0], p[1]):
+                    tPerm[i] = j
+            obsSet.add("".join(tPerm))
+    return obsSet
+
+
+def enumerateImplicants(func):
+    """Enumerate the input conditions and their outputs of the given function"""
+    implicants = {"0": set(), "1": set()}
+    k = int(math.log(len(func)) / math.log(2))
+    for i, output in enumerate(func, start=0):
+        cond = f"{bin(i)[2:]:0>{k}}"
+        implicants[output].add(cond)
+    return implicants
+
+
+# each element of pi is a string
+def expandPi(pi):
+    """Expand a schemata with don't cares into the set of all schema it encodes"""
+    out = set()
+    for s in pi:
+        # count number of 2s
+        n = sum(1 for i in s if int(i) == 2)
+        idxs = [i for i in range(len(s)) if s[i] == "2"]
+        # get all permutations of 0 and 1 of that length
+        # for perm in permutations("01", n):
+        for perm in product(*["01"] * n):
+            # print(perm)
+            slist = list(s)
+            # produce substitution of each
+            for k, i in enumerate(idxs):
+                slist[i] = perm[k]
+            out.add("".join(slist))
+    return out
+
+
+def compare(pi, ts):
+    """test if two functions represented by schemata are the same.
+    Args:
+        pi: the one-symbol schemata of function 1
+        ts: the two-symbol schemata of function 2
+    Returns:
+        3-tuple (bool, set, set)
+    """
+    x = expandPi(expandTs(ts))
+    y = expandPi(pi)
+    return x == y, x - y, y - x
+
+
+def getPis(outputs):
+    """Compute prime implicants from a string function representation"""
+    k = int(math.log(len(outputs)) / math.log(2))
+    node = BooleanNode(k=k, inputs=range(k), outputs=list(outputs))
+    node._check_compute_canalization_variables(prime_implicants="i dont matter")
+    pi = node._prime_implicants
+    return {
+        0: set(i.replace("#", "2") for i in pi["0"]),
+        1: set(i.replace("#", "2") for i in pi["1"]),
+    }
+
+
+def getCCnodes():
+    networks = load_all_cell_collective_models()
+    nodes = []
+    for network in networks:
+        for node in network.nodes:
+            if (
+                node.k < 8 and "1" in node.outputs and "0" in node.outputs
+            ):  # select non-constant with k<=7
+                nodes.append(node)
+    # fs = ["".join(n.outputs) for n in nodes]
+    return nodes
diff --git a/tests/test_boolean_canalization.py b/tests/test_boolean_canalization.py
index e374b20..c34ccb2 100644
--- a/tests/test_boolean_canalization.py
+++ b/tests/test_boolean_canalization.py
@@ -5,9 +5,10 @@
 # Checks were made with the online tool: http://www.mathematik.uni-marburg.de/~thormae/lectures/ti1/code/qmc/
 #
 # from cana.canalization.boolean_canalization import *
+import pytest
 from cana.canalization.cboolean_canalization import find_implicants_qm
 from cana.cutils import outputs_to_binstates_of_given_type
-from helpers.helper import reorderTwoSymbolOutput, randNode, enumerateImplicants, expandPi
+from tests.helpers.helper import reorderTwoSymbolOutput, randNode, enumerateImplicants, expandPi
 from cana.canalization.boolean_canalization import find_two_symbols_v2
 
 def test_AND():
diff --git a/tests/test_boolean_node.py b/tests/test_boolean_node.py
index 0c22148..37bc0b5 100644
--- a/tests/test_boolean_node.py
+++ b/tests/test_boolean_node.py
@@ -3,7 +3,9 @@
 # Tests for ``boolean_node.py``
 # These tests were manually calculated by Luis M. Rocha and implemented by Rion B. Correia.
 #
-from cana.datasets.bools import CONTRADICTION, AND, OR, XOR, COPYx1, RULE90, RULE110
+import pytest
+
+from cana.datasets.bools import CONTRADICTION, AND, OR, XOR, COPYx1, RULE90, RULE110, GP
 from cana.utils import isclose, fill_out_lut
 from cana.boolean_node import BooleanNode
 
@@ -910,7 +912,7 @@ def test_generate_with_required_node_bias():
         generated_node_permuations = None
         node = BooleanNode.from_partial_lut(incomplete_automata[automata])
 
-        generated_node_permuations = BooleanNode.generate_with_required_bias( node, required_node_bias=0.5, verbose=True)
+        generated_node_permuations = BooleanNode.generate_with_required_bias( node, bias=0.5, verbose=True)
         list_of_output_lists = [node.outputs for node in generated_node_permuations]
 
         # print(automata)
@@ -920,3 +922,124 @@ def test_generate_with_required_node_bias():
         #     print("No match found")
 
         assert automata_output_list[automata] in list_of_output_lists, "No match found"
+
+
+@pytest.fixture
+def annigen_node():
+    return BooleanNode.from_output_list([1] + [0] * 15)
+
+
+@pytest.fixture
+def gp_node():
+    return GP()
+
+
+def test_get_annihilation_generation_rules_wildcard(annigen_node):
+    anni, gen = annigen_node.get_annihilation_generation_rules(split=True)
+    assert anni == [("###1", 0)]
+    assert gen == [("0000", 1)]
+    combined = annigen_node.get_annihilation_generation_rules()
+    assert combined == [("###1", 0), ("0000", 1)]
+
+
+def test_get_annihilation_generation_rules_two_symbol(annigen_node):
+    anni, gen = annigen_node.get_annihilation_generation_rules(type="ts", split=True)
+    assert anni == [["###1", []]]
+    assert gen == [["0000", []]]
+
+
+def test_get_anni_gen_coverage_wildcard(annigen_node):
+    coverage = annigen_node.get_anni_gen_coverage()
+    expected_non_empty = {
+        "0000": {"0000"},
+        "0001": {"###1"},
+        "0011": {"###1"},
+        "0101": {"###1"},
+        "0111": {"###1"},
+        "1001": {"###1"},
+        "1011": {"###1"},
+        "1101": {"###1"},
+        "1111": {"###1"},
+    }
+    for key, value in expected_non_empty.items():
+        assert coverage[key] == value
+    for key, value in coverage.items():
+        if key not in expected_non_empty:
+            assert value == set()
+
+
+def test_get_anni_gen_coverage_two_symbol(annigen_node):
+    coverage = annigen_node.get_anni_gen_coverage(type="ts")
+    expected = {
+        "0000": [["0000", [], [[0, 1, 2, 3]]]],
+        "0001": [["2221", [], [[0, 1, 2]]]],
+        "0011": [["2221", [], [[0, 1, 2]]]],
+        "0101": [["2221", [], [[0, 1, 2]]]],
+        "0111": [["2221", [], [[0, 1, 2]]]],
+        "1001": [["2221", [], [[0, 1, 2]]]],
+        "1011": [["2221", [], [[0, 1, 2]]]],
+        "1101": [["2221", [], [[0, 1, 2]]]],
+        "1111": [["2221", [], [[0, 1, 2]]]],
+    }
+    for key, value in expected.items():
+        assert coverage[key] == value
+    for key, value in coverage.items():
+        if key not in expected:
+            assert value == []
+
+
+def test_input_symmetry_mean_anni_gen(annigen_node):
+    assert annigen_node.input_symmetry_mean_anni_gen() == 0.0
+    assert annigen_node.input_symmetry_mean_anni_gen(norm=True) == 0.0
+
+
+def test_input_redundancy_anni_gen(annigen_node):
+    assert annigen_node.input_redundancy_anni_gen() == pytest.approx(8 / 3)
+    assert annigen_node.input_redundancy_anni_gen(norm=True) == pytest.approx(2 / 3)
+
+
+def test_effective_connectivity_anni_gen(annigen_node):
+    assert annigen_node.effective_connectivity_anni_gen() == pytest.approx(4 / 3)
+    assert annigen_node.effective_connectivity_anni_gen(norm=True) == pytest.approx(1 / 3)
+
+
+def test_get_annihilation_generation_rules_wildcard_gp(gp_node):
+    anni, gen = gp_node.get_annihilation_generation_rules(split=True)
+    assert set(anni) == {("0##10##", 0), ("0#01###", 0), ("0##1##0", 0)}
+    assert set(gen) == {("1##0##1", 1), ("##10##1", 1), ("###01#1", 1)}
+
+
+def test_get_annihilation_generation_rules_two_symbol_gp(gp_node):
+    anni, gen = gp_node.get_annihilation_generation_rules(type="ts", split=True)
+    assert anni == [["0#01###", [[2, 4, 6]]]]
+    assert gen == [["1##0##1", [[0, 2, 4]]]]
+
+
+def test_get_anni_gen_coverage_wildcard_gp(gp_node):
+    coverage = gp_node.get_anni_gen_coverage()
+    assert coverage["0001000"] == {"0##1##0", "0##10##", "0#01###"}
+    assert coverage["0011110"] == {"0##1##0"}
+    assert coverage["0000101"] == {"###01#1"}
+    assert coverage["1111010"] == set()
+
+
+def test_get_anni_gen_coverage_two_symbol_gp(gp_node):
+    coverage = gp_node.get_anni_gen_coverage(type="ts")
+    assert coverage["0001000"] == [["0201222", [[2, 4, 6]], [[0, 2], [1, 4, 5, 6]]]]
+    assert coverage["0000101"] == [["1220221", [[0, 2, 4]], [[0, 6], [1, 2, 4, 5]]]]
+    assert coverage["1111010"] == []
+
+
+def test_input_symmetry_mean_anni_gen_gp(gp_node):
+    assert gp_node.input_symmetry_mean_anni_gen() == pytest.approx(3.0)
+    assert gp_node.input_symmetry_mean_anni_gen(norm=True) == pytest.approx(3.0 / 7.0)
+
+
+def test_input_redundancy_anni_gen_gp(gp_node):
+    assert gp_node.input_redundancy_anni_gen() == pytest.approx(4.0)
+    assert gp_node.input_redundancy_anni_gen(norm=True) == pytest.approx(4.0 / 7.0)
+
+
+def test_effective_connectivity_anni_gen_gp(gp_node):
+    assert gp_node.effective_connectivity_anni_gen() == pytest.approx(3.0)
+    assert gp_node.effective_connectivity_anni_gen(norm=True) == pytest.approx(3.0 / 7.0)
diff --git a/tests/test_schema_search_tools.py b/tests/test_schema_search_tools.py
new file mode 100644
index 0000000..8aedc42
--- /dev/null
+++ b/tests/test_schema_search_tools.py
@@ -0,0 +1,49 @@
+# tests for schema_search_tools.py
+import pytest
+from cana.boolean_node import BooleanNode
+from automata.schema_search_tools import annihilation_generation_rules, maintenance_rules, fill_missing_outputs_as_maintenance
+from automata.automata_rules import automata_output_list, annihilation_generation
+
+def test_annihilation_generation_maintenance_rules():
+    """
+    Splitting a rule into their annihilation_generation and maintenance. Then combining them again to check if we get the original rule.
+    """
+    anni_gen = {}
+    maintenance = {}
+    for item in automata_output_list:
+        n = BooleanNode.from_output_list(automata_output_list[item])
+        anni_gen[item] = n.get_annihilation_generation_rules()
+        assert sorted(anni_gen[item]) == sorted(annihilation_generation[item]), (
+            f"{item}: Annihilation, generation rules are not correct."
+        )
+
+        maintenance[item] = maintenance_rules(automata_output_list[item])
+
+        combo = []
+        combo = anni_gen[item] + maintenance[item]
+        combo_node = BooleanNode.from_partial_lut(combo)
+        parent_node = BooleanNode.from_output_list(automata_output_list[item])
+
+        assert combo_node.outputs == parent_node.outputs, "Maintenance rules combined with annihilation and generation rules do not return the original rule. "
+
+
+def test_missing_outputs_as_maintenance():
+    """
+    Test the fill_missing_outputs_as_maintenance function.
+    """
+    for item in automata_output_list:
+        node1 = BooleanNode.from_output_list(["0", "?", "1", "?", "0", "0", "1", "?"])
+        expected1 = ["0", "0", "1", "1", "0", "0", "1", "1"]
+        assert fill_missing_outputs_as_maintenance(node1).outputs == expected1
+
+        # Test case: No missing output values
+        node3 = BooleanNode.from_output_list(["1", "0", "1", "0", "1", "1", "0", "1"])
+        # with pytest.raises(ValueError, match="There are no missing output values in the node."):
+        #     fill_missing_outputs_as_maintenance(node3)
+        expected3 = ["1", "0", "1", "0", "1", "1", "0", "1"]
+        assert fill_missing_outputs_as_maintenance(node3).outputs == expected3
+
+        # Test case: All missing output values
+        node4 = BooleanNode.from_output_list(["?", "?", "?", "?", "?", "?", "?", "?"])
+        expected4 = ["0", "0", "1", "1", "0", "0", "1", "1"]
+        assert fill_missing_outputs_as_maintenance(node4).outputs == expected4
\ No newline at end of file
diff --git a/tests/test_two_symbol_symmetry.py b/tests/test_two_symbol_symmetry.py
index 05c83af..998bf4e 100644
--- a/tests/test_two_symbol_symmetry.py
+++ b/tests/test_two_symbol_symmetry.py
@@ -1,6 +1,6 @@
 import math
 
-import helpers.helper as helper
+from tests.helpers import helper
 
 from cana.boolean_node import BooleanNode
 
diff --git a/tutorials/Generating from Partial LUTs.ipynb b/tutorials/Generating from Partial LUTs.ipynb
index d10cf51..440fc3c 100644
--- a/tutorials/Generating from Partial LUTs.ipynb	
+++ b/tutorials/Generating from Partial LUTs.ipynb	
@@ -158,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -182,7 +182,7 @@
        " ('1111', '0')]"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -197,7 +197,7 @@
     "    [(\"0--0\", \"0\"), (\"1--1\", \"0\"), (\"0111\", \"1\"), (\"0011\", \"1\")],\n",
     "    [(\"1---\", \"0\")],\n",
     "]\n",
-    "generated_lut = fill_out_lut(partial_luts[3])\n",
+    "generated_lut = fill_out_lut(partial_luts[3], fill_clashes=True)\n",
     "generated_lut"
    ]
   },
@@ -212,7 +212,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
@@ -223,7 +223,7 @@
       "['0', '0', '0', '0', '?', '?', '?', '?', '?', '1', '?', '1', '1', '1', '?', '1']\n",
       "Clashing output values for entry: 101\n",
       "Clashing output values for entry: 011\n",
-      "['?', '?', '1', '!', '1', '!', '1', '1']\n",
+      "['?', '?', '1', '1', '1', '1', '1', '1']\n",
       "['0', '?', '0', '1', '0', '?', '0', '1', '?', '0', '?', '0', '?', '0', '?', '0']\n",
       "['?', '?', '?', '?', '?', '1', '0', '1', '?', '1', '0', '0', '?', '1', '0', '0']\n",
       "['?', '?', '?', '?', '?', '?', '0', '?', '?', '1', '0', '0', '?', '1', '0', '0']\n",
@@ -249,7 +249,7 @@
     "\n",
     "# using the from_partial_lut function found in BooleanNode class\n",
     "for partial_lut in partial_luts:\n",
-    "    generated_node = BooleanNode.from_partial_lut(partial_lut)\n",
+    "    generated_node = BooleanNode.from_partial_lut(partial_lut, fill_clashes=True)\n",
     "    # print(generated_node)\n",
     "    print(generated_node.outputs)\n",
     "    # plot_look_up_table(generated_node)\n",
@@ -272,8 +272,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<BNode(id=0, name='x', k=4, inputs=[1,2,3,4], state='0', outputs=[0,0,1,1...1,1,0,0] constant=False)>\n",
-      "['0', '0', '1', '1', '0', '0', '0', '0', '0', '1', '0', '0', '1', '1', '0', '0']\n"
+      "<BNode(id=0, name='x', k=4, inputs=[1,2,3,4], state='0', outputs=[0,1,0,0...1,1,0,0] constant=False)>\n",
+      "['0', '1', '0', '0', '0', '0', '0', '0', '0', '1', '0', '0', '1', '1', '0', '0']\n"
      ]
     }
    ],
@@ -311,6 +311,9 @@
      "text": [
       "2.80e+01 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
       "3.50e+01 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
+      "Clashing output values for entry: 101\n",
+      "Clashing output values for entry: 011\n",
+      "1.00e+00 possible permutation(s) with a bias of 0.75. This is the closest achievable bias to the required bias of 0.5.\n",
       "1.00e+00 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
       "3.50e+01 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
       "8.40e+01 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
@@ -318,13 +321,21 @@
       "4.95e+02 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n",
       "7.00e+01 possible permutation(s) with a bias of 0.5. This is the closest bias less than or equal to the required bias of 0.5.\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/data/siyer/CANA/cana/boolean_node.py:1075: UserWarning: Required Node Bias is lower than the minimum achievable bias (0.75) of the node. Generating with the minimum achievable bias.\n",
+      "  warnings.warn(\n"
+     ]
     }
    ],
    "source": [
     "partial_luts = [\n",
     "    [(\"001-\", \"0\"), (\"1--1\", \"1\"), (\"11--\", \"1\")],\n",
     "    [(\"00--\", \"0\"), (\"1--1\", \"1\"), (\"110-\", \"1\")],\n",
-    "    # [(\"1--\", \"1\"), (\"101\", \"0\"), (\"011\", \"0\"), (\"01-\", \"1\")], # will have clashes\n",
+    "    [(\"1--\", \"1\"), (\"101\", \"0\"), (\"011\", \"0\"), (\"01-\", \"1\")], # will have clashes\n",
     "    [(\"0--0\", \"0\"), (\"1--1\", \"0\"), (\"0111\", \"1\"), (\"0011\", \"1\")],\n",
     "    [(\"1-01\", \"1\"), (\"1-1-\", \"0\"), (\"0110\", \"0\"), (\"01-1\", \"1\")],\n",
     "    [(\"1-01\", \"1\"), (\"1-1-\", \"0\"), (\"0110\", \"0\"), (\"01-1\", \"?\")],\n",
@@ -337,11 +348,11 @@
     "for lut in partial_luts:\n",
     "    node = None\n",
     "    # generated_node_permutations = None\n",
-    "    node = BooleanNode.from_partial_lut(lut)\n",
+    "    node = BooleanNode.from_partial_lut(lut, fill_clashes=True)\n",
     "    # print(node.outputs)\n",
     "\n",
     "    generated_node_permutations = node.generate_with_required_bias(\n",
-    "        required_node_bias=0.5, limit=50, verbose=True\n",
+    "        bias=0.5, limit=50, verbose=True\n",
     "    )\n",
     "    # print(generated_node_permuations[0].outputs, \"\\n\")"
    ]
@@ -354,7 +365,7 @@
     {
      "data": {
       "text/plain": [
-       "['1', '0', '1', '0', '0', '0', '1', '1']"
+       "['0', '1', '1', '1', '0', '0', '0', '1']"
       ]
      },
      "execution_count": 7,
@@ -400,64 +411,111 @@
      "output_type": "stream",
      "text": [
       "Partial LUT: ['?', '?', '0', '0', '?', '?', '?', '?', '?', '1', '?', '1', '1', '1', '1', '1']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '0', '0', '1', '1', '0', '1', '1', '1', '1', '1', '1', '1', '1'] \n",
+      "No. of '?' in output = 8.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '0', '0', '0', '1', '1', '0', '1', '0', '1', '1', '1', '1', '1']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n",
       "Partial LUT: ['0', '0', '0', '0', '?', '?', '?', '?', '?', '1', '?', '1', '1', '1', '?', '1']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '0', '1'] \n",
+      "No. of '?' in output = 7.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '0', '0', '0', '1', '1', '0', '1', '0', '1', '1', '1', '1', '1']\n",
+      "Ec = 0.5.\n",
+      "True \n",
+      "\n",
+      "Clashing output values for entry: 101\n",
+      "Clashing output values for entry: 011\n",
+      "Partial LUT: ['?', '?', '1', '1', '1', '1', '1', '1']\n",
+      "No. of '?' in output = 2.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '1', '1', '1', '1', '1', '1']\n",
+      "Ec = 0.4166666666666667.\n",
+      "False \n",
       "\n",
       "Partial LUT: ['0', '?', '0', '1', '0', '?', '0', '1', '?', '0', '?', '0', '?', '0', '?', '0']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '1', '0', '0', '0', '1', '0', '0', '0', '0', '0', '0', '1', '0'] \n",
+      "No. of '?' in output = 6.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '1', '0', '1', '0', '1', '0', '1', '1', '0', '1', '0', '1', '0', '1', '0']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n",
       "Partial LUT: ['?', '?', '?', '?', '?', '1', '0', '1', '?', '1', '0', '0', '?', '1', '0', '0']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['1', '1', '1', '0', '1', '1', '0', '1', '1', '1', '0', '0', '1', '1', '0', '0'] \n",
+      "No. of '?' in output = 7.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '1', '0', '1', '0', '1', '0', '1', '0', '0', '0', '1', '0', '0']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n",
       "Partial LUT: ['?', '?', '?', '?', '?', '?', '0', '?', '?', '1', '0', '0', '?', '1', '0', '0']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '0', '0', '0', '0', '1', '0', '1', '0', '0', '0', '1', '0', '0'] \n",
+      "No. of '?' in output = 9.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '0', '1', '1', '0', '0', '1', '1', '0', '0', '0', '1', '0', '0']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n",
       "Partial LUT: ['?', '?', '?', '?', '0', '0', '0', '0', '?', '?', '?', '?', '0', '0', '0', '0']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '1', '0', '0', '0', '0', '1', '0', '0', '1', '0', '0', '0', '0'] \n",
+      "No. of '?' in output = 8.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '1', '0', '0', '0', '0', '1', '0', '0', '0', '0', '0', '0', '0']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n",
       "Partial LUT: ['?', '?', '?', '?', '1', '1', '1', '1', '?', '?', '?', '?', '1', '1', '1', '1']\n",
-      "Generated the node with the closest possible effective connectivity of 0.484375.\n",
-      "['0', '0', '0', '0', '1', '1', '1', '1', '0', '1', '1', '0', '1', '1', '1', '1'] \n",
+      "No. of '?' in output = 8.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '1', '1', '1', '1', '1', '1', '0', '0', '1', '1', '1', '1', '1']\n",
+      "Ec = 0.5.\n",
+      "True \n",
+      "\n",
+      "Partial LUT: ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?']\n",
+      "No. of '?' in output = 16.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.5.\n",
+      "['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '0', '0', '0']\n",
+      "Ec = 0.5.\n",
+      "True \n",
       "\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/data/siyer/CANA/cana/boolean_node.py:1266: UserWarning: No node within 0.01 of 0.5 (required effective connectivity) found.\n",
+      "Generating a node with the closest effective connectivity of 0.4166666666666667\n",
+      "  warnings.warn(\n"
+     ]
     }
    ],
    "source": [
     "partial_luts = [\n",
     "    [(\"001-\", \"0\"), (\"1--1\", \"1\"), (\"11--\", \"1\")],\n",
     "    [(\"00--\", \"0\"), (\"1--1\", \"1\"), (\"110-\", \"1\")],\n",
-    "    # [(\"1--\", \"1\"), (\"101\", \"0\"), (\"011\", \"0\"), (\"01-\", \"1\")], # will have clashes\n",
+    "    [(\"1--\", \"1\"), (\"101\", \"0\"), (\"011\", \"0\"), (\"01-\", \"1\")], # will have clashes\n",
     "    [(\"0--0\", \"0\"), (\"1--1\", \"0\"), (\"0111\", \"1\"), (\"0011\", \"1\")],\n",
     "    [(\"1-01\", \"1\"), (\"1-1-\", \"0\"), (\"0110\", \"0\"), (\"01-1\", \"1\")],\n",
     "    [(\"1-01\", \"1\"), (\"1-1-\", \"0\"), (\"0110\", \"0\"), (\"01-1\", \"?\")],\n",
     "    [(\"-1--\", \"0\")],\n",
     "    [(\"-1--\", \"1\")],\n",
-    "    # [(\"-1--\",\"?\")]\n",
+    "    [(\"-1--\",\"?\")]\n",
     "]\n",
     "partial_lut = partial_luts[0]\n",
     "\n",
     "for partial_lut in partial_luts:\n",
-    "    generated_nodes = BooleanNode.from_partial_lut(partial_lut)\n",
+    "    generated_nodes = BooleanNode.from_partial_lut(partial_lut, fill_clashes=True)\n",
     "    print(f\"Partial LUT: {generated_nodes.outputs}\")\n",
-    "    generated_node_permuations = (\n",
-    "        generated_nodes.generate_with_required_effective_connectivity(\n",
-    "            required_effective_connectivity=0.49, verbose=True\n",
-    "        )\n",
+    "    generated_node_permutations = (\n",
+    "        generated_nodes.generate_with_required_effective_connectivity(effective_connectivity=0.5, epsilon = 0.01, verbose=True)\n",
     "    )\n",
-    "    print(generated_node_permuations.outputs, \"\\n\")\n",
+    "    perm = next(generated_node_permutations)\n",
+    "    print(perm.outputs)\n",
+    "    print(f\"Ec = {perm.effective_connectivity()}.\")\n",
+    "    print(perm.is_within_tolerance(effective_connectivity=0.5, epsilon=0.01),\"\\n\")\n",
     "\n",
     "\n",
     "# # Incorporating the above functions into the from_partial_lut() under BooleanNode class\n",
     "# generated_node = BooleanNode.from_partial_lut(\n",
-    "#     partial_lut, required_effective_connectivity=0.45\n",
+    "#     partial_lut, effective_connectivity=0.45\n",
     "# )\n",
     "\n",
     "# plot_look_up_table(generated_node)\n",
@@ -465,23 +523,69 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 9,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## Note: \n",
-    "\n",
-    "from_partial_lut() will throw an error if there are mutliple kwargs inputted. "
+    "automata = {'GKL': [['###10#0', 0], ['1#10###', 1]],\n",
+    " 'GP': [['0##1##0', 0],\n",
+    "  ['0##10##', 0],\n",
+    "  ['0#01###', 0],\n",
+    "  ['##10##1', 1],\n",
+    "  ['1##0##1', 1],\n",
+    "  ['###01#1', 1]],\n",
+    "}"
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "No. of '?' in output = 72.\n",
+      "Returning a generator of nodes with effective connectivity within 0.01 of 0.4.\n"
+     ]
+    }
+   ],
    "source": [
-    "```python\n",
-    "generated_node = BooleanNode.from_partial_lut(partial_lut, fill_missing_output_randomly= True, required_effective_connectivity=0.7, required_node_bias=0.5)\n",
+    "generated_node = BooleanNode.from_partial_lut(automata['GP'])\n",
+    "effective_connectivity = 0.4\n",
+    "bias = None\n",
+    "verbose = True\n",
+    "epsilon = 0.01\n",
+    "shuffle = True  \n",
     "\n",
-    "ValueError: Only one of required_effective_connectvity, required_node_bias and fill_missing_output_randomly can be True. Please set the rest to False.\n",
-    "```"
+    "\n",
+    "generated_node_permutations = generated_node.generate_with_required_effective_connectivity(\n",
+    "    effective_connectivity=effective_connectivity,\n",
+    "    bias=bias,\n",
+    "    epsilon=epsilon,\n",
+    "    shuffle=shuffle,\n",
+    "    verbose=verbose,\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.393945272237683\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(next(generated_node_permutations).effective_connectivity())"
    ]
   }
  ],