diff --git a/.gitignore b/.gitignore
index 364f5d3b8a11507401fa26de3053b8fbe2c7d95e..9db9f497880613dab91d9fbca3cbe3bb18399200 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,4 +16,5 @@ _local_tmp
 doc/bibtex.json
 /db
 /lbmpy/phasefield/simplex_projection.*.so
-/lbmpy/phasefield/simplex_projection.c
\ No newline at end of file
+/lbmpy/phasefield/simplex_projection.c
+*.swp
diff --git a/lbmpy/sparse/mapping.py b/lbmpy/sparse/mapping.py
index f5f116ca1d8f0a77edbc90ac66849a56fbdafbd1..d50992d231e1dc02c1d16a357b09d1c9210d4d34 100644
--- a/lbmpy/sparse/mapping.py
+++ b/lbmpy/sparse/mapping.py
@@ -132,13 +132,14 @@ class SparseLbMapper:
         print("flag:", self.flag_array)
         fucking_counter = 0
         for direction_idx, direction in enumerate(stencil):
+            print("dir:", direction_idx)
             if all(d_i == 0 for d_i in direction):
                 assert direction_idx == 0
                 continue
             for own_cell_idx, cell in enumerate(self.fluid_coordinates):
                 if (cell[0] == 0 or cell[0] == self.domain_size[0]-1 or cell[1] == 0 or cell[1] == self.domain_size[1]-1):
-                    fucking_counter += 1
-                    continue #ignore fluid cells at the border ... 
+                    fucking_counter += 1 #count skipped border cells for reshape function later
+                    continue #ignore fluid cells at the border ...
                 domain_size = (len(self.flag_array), len(self.flag_array[0]))
                 test = []
                 inv_neighbor_cell = np.array([cell_i - dir_i for cell_i, dir_i in zip(cell, direction)])
@@ -171,8 +172,9 @@ class SparseLbMapper:
                 #print(test)
 
         index_array = np.array(result, dtype=np.uint32)
-        index_arr = index_array.reshape([len(stencil) - 1, self.num_fluid_cells-fucking_counter])
-        index_arr = index_arr.swapaxes(0, 1)
+        print("number of fluid:", self.num_fluid_cells, "counter:", fucking_counter//8)
+        index_arr = index_array.reshape([len(stencil) - 1, self.num_fluid_cells-fucking_counter//8])
+        index_arr = index_arr.swapaxes(0, 1) 
         return index_arr
 
     
@@ -206,11 +208,11 @@ class SparseLbPeriodicityMapper:
         stencil = self.method.stencil
         print("domain_size:", self.domain_size)
         result = []
-        inner = []
+        inner_idx_array = []
         write = [0,0]
         fluid_boundary_mask = self.fluid_flag | self.ubb_flag | self.density_flag
         for direction_idx, direction in enumerate(stencil):
-            if all(d_i == 0 for d_i in direction) or direction_idx < 5:#(direction_idx != 5 and direction_idx != 1) or direction_idx < 5: # direction (0,0) irrelevant
+            if all(d_i == 0 for d_i in direction):#(direction_idx != 5 and direction_idx != 1) or direction_idx < 5: # direction (0,0) irrelevant
                 continue
             print("\n New direction:", direction, ", ", direction_idx)
             for pos in range(0,2): # einmal für x, einmal für y Richtung ... 
@@ -219,7 +221,7 @@ class SparseLbPeriodicityMapper:
                 if direction[pos] != 0:
                     # periodic/parallel: wird an anderen Block geschickt/periodisch gewrappt
                     print("(periodic:)")
-                    index_array = []
+                    periodic_idx_array = []
                     coord = int((self.domain_size[pos]-1)*(1-direction[pos])/2)
                     print("first")
                     start = 1 if direction[sop] == 1 else 0
@@ -231,15 +233,16 @@ class SparseLbPeriodicityMapper:
                         if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                             continue
                         read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
-                        if self.flag_arr[tuple(read)] & self.no_slip_flag:
-                            print("Read cell is a no_slip. Hmpf.")
+                        write_idx = pdf_index(self.cell_idx(tuple(write)), direction_idx, len(self.mapping))
+                        read_idx = pdf_index(self.cell_idx(tuple(read)), direction_idx, len(self.mapping))
+                        if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip: flip PDF!
+                            #read from write cell, inverse direction
+                            read_idx = pdf_index(write_idx, inverse_idx(stencil, direction_idx), len(self.mapping))
+                        periodic_idx_array.append([direction_idx, write_idx, read_idx])
                         # "Die Zelle "write" bekommt ihren neuen Wert der jeweiligen direction von der Zelle "read"
                         print("write:", write, "read:", read) 
-                        #write_idx = self.cell_idx(tuple(write))
-                        #read_idx = self.cell_idx(tuple(read))
-                        #index_array.append((direction_idx, pdf_index(write_idx, direction_idx, len(self.mapping)), pdf_index(read_idx, direction_idx, len(self.mapping))))
-                        index_array.append([direction_idx, write, read]) #nur zu debug Zwecken
-                    result.append(tuple(index_array))
+                        #periodic_idx_array.append([direction_idx, write, read]) #nur zu debug Zwecken
+                    result.append(tuple(periodic_idx_array))
                     # inner: wird zwischen benachbarten Zellen *im gleichen Block* geschickt
                     print("(inner:)")
                     pos_bound = int((self.domain_size[pos]-1)*(1+direction[pos])/2)
@@ -255,10 +258,14 @@ class SparseLbPeriodicityMapper:
                             if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                                 continue
                             read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
-                            if self.flag_arr[tuple(read)] & self.no_slip_flag:
-                                print("Read cell is a no_slip. Hmpf.")
+                            write_idx = pdf_index(self.cell_idx(tuple(write)), direction_idx, len(self.mapping))
+                            read_idx = pdf_index(self.cell_idx(tuple(read)), direction_idx, len(self.mapping))
+                            if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip: flip PDF!
+                                #read from write cell, inverse direction
+                                read_idx = pdf_index(write_idx, inverse_idx(stencil, direction_idx), len(self.mapping))
+                            inner_idx_array.append([direction_idx, write_idx, read_idx])
                             print("write:", write, "read:", read)
-                            inner.append([direction_idx, write, read])
+                            #inner_idx_array.append([direction_idx, write, read]) #for debug
                 if direction[pos] == 0: #spricht directions 1, 2, 3 und 4 an
                     # inner: wird zwischen benachbarte Zellen *im gleichen Block* geschickt
                     print("(inner:)")
@@ -274,21 +281,29 @@ class SparseLbPeriodicityMapper:
                         if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                             continue
                         read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
-                        if self.flag_arr[tuple(read)] & self.no_slip_flag:
-                            print("Read cell is a no_slip. Hmpf.")
+                        write_idx = pdf_index(self.cell_idx(tuple(write)), direction_idx, len(self.mapping))
+                        read_idx = pdf_index(self.cell_idx(tuple(read)), direction_idx, len(self.mapping))
+                        if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip: flip PDF!
+                            #read from write cell, inverse direction
+                            read_idx = pdf_index(write_idx, inverse_idx(stencil, direction_idx), len(self.mapping))
+                        inner_idx_array.append([direction_idx, write_idx, read_idx])
                         print("write:", write, "read:", read)
-                        inner.append([direction_idx, write, read])
-            write = [int((self.domain_size[0]-1)*(1-direction[0])/2),int((self.domain_size[1]-1)*(1-direction[1])/2)]
-            if not (self.flag_arr[tuple(write)] & self.fluid_flag):
-                continue
-            read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
-            #write_idx = self.cell_idx(tuple(write))
-            #read_idx = self.cell_idx(tuple(read))
-            #index_array.append((direction_idx, pdf_index(write_idx, direction_idx, len(self.mapping)), pdf_index(read_idx, direction_idx, len(self.mapping))))
-            index_array = []
-            index_array.append([direction_idx, write, read]) #nur zu debug Zwecken
-            result.append(tuple(index_array))
-            print("(Ecke) write:", write, "read:", read)
+                        #inner_idx_array.append([direction_idx, write, read]) #for debug
+            #Four corners: extra periodic_idx_array for each direction 5, 6, 7, 8
+            if (direction[0]*direction[1] != 0):
+                write = [int((self.domain_size[0]-1)*(1-direction[0])/2),int((self.domain_size[1]-1)*(1-direction[1])/2)]
+                if not (self.flag_arr[tuple(write)] & self.fluid_flag):
+                    continue
+                read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
+                write_idx = pdf_index(self.cell_idx(tuple(write)), direction_idx, len(self.mapping))
+                read_idx = pdf_index(self.cell_idx(tuple(read)), direction_idx, len(self.mapping))
+                if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip: flip PDF!
+                    #read from write cell, inverse direction
+                    read_idx = pdf_index(write_idx, inverse_idx(stencil, direction_idx), len(self.mapping))
+                periodic_idx_array.append([direction_idx, write_idx, read_idx])
+                #periodic_idx_array.append([direction_idx, write, read]) #nur zu debug Zwecken
+                result.append(tuple(periodic_idx_array))
+                print("(Ecke) write:", write, "read:", read)
             
         # result enthält *mehrere* index arrays
         #result = list(dict.fromkeys(result)) # entferne doppelte index_arrays: speziell Ecken der Domain
@@ -303,101 +318,12 @@ class SparseLbPeriodicityMapper:
             list_result.append(list_index_array)
         
         # zu den periodischen/parralel-orientierten index_arrays kommt noch der index array für die Werte, die nur innerhalb des Blocks verschickt werden:
-        list_result.append(inner)
-        print("start")
+        list_result.append(inner_idx_array)
         for index_array in list_result:
             print(index_array)
-        print("end")
         return list_result
     
     
-    def create_index_arr_old(self): # erstellt index arrays für ALLE fluid Zellen, die sich am Rand der domain befinden.
-        # ein index array für alle Werte, die innerhalb des Blocks verschickt werden
-        # jeweils ein index array für Werte, die zu jeweils verschiedenen benachbarten Blocks geschickt werden (wenn verschiedene Kerne verschiedene Blöcke innerhalb einer Domain bearbeiten)
-        stencil = self.method.stencil
-        print("domain_size:", self.domain_size)
-        result = []
-        inner = []
-        for direction_idx, direction in enumerate(stencil):
-            if all(d_i == 0 for d_i in direction): # direction (0,0) irrelevant
-                continue
-            print("\n New direction:", direction, ", ", direction_idx)
-            for pos in range(0,2): # einmal für x, einmal für y Richtung ... 
-                sop = (pos+1)%2
-                if direction[pos] != 0:
-                    # periodic/parallel: wird an anderen Block geschickt/periodisch gewrappt
-                    print("(periodic:)")
-                    index_array = []
-                    coord = int((self.domain_size[pos]-1)*(1-direction[pos])/2)
-                    prev_read = [0,0]
-                    for i in range(0, self.domain_size[sop]):
-                        write = [0,0]
-                        cur_read = [0,0]
-                        write[pos] = coord
-                        write[sop] = i
-                        cur_read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
-                        if cur_read[pos] < prev_read[pos] or cur_read[sop] < prev_read[sop]:
-                            #index_array wird abgetrennt und neu begonnen, da hier Kommunikation mit einem anderen Block als vorher geschieht
-                            result.append(tuple(index_array)) 
-                            index_array = []
-                            print("--cut--")
-                        print("write:", write, "read:", cur_read) # "Die Zelle "write" bekommt ihren neuen Wert der jeweiligen direction von der Zelle "read"
-                        write_idx = self.cell_idx(tuple(write))
-                        read_idx = self.cell_idx(tuple(cur_read))
-                        index_array.append((direction_idx, pdf_index(write_idx, direction_idx, len(self.mapping)), pdf_index(read_idx, direction_idx, len(self.mapping))))
-                        #index_array.append([direction_idx, write, cur_read]) #nur zu debug Zwecken
-                        prev_read[pos] = cur_read[pos]
-                        prev_read[sop] = cur_read[sop]
-                    result.append(tuple(index_array))
-                    
-                    # inner: wird zwischen benachbarten Zellen *im gleichen Block* geschickt
-                    print("(inner:)")
-                    pos_bound = int((self.domain_size[pos]-1)*(1+direction[pos])/2)
-                    pos_mid = pos_bound+direction[pos]*(-self.domain_size[pos]+1)
-                    sop_position = [int((self.domain_size[sop]-1)*(1+direction[sop])/2)] if direction[sop] != 0 else [0, self.domain_size[sop]-1]
-                    #print("pos_bound:", pos_bound, "pos_mid", pos_mid, "sop_position:", sop_position)
-                    for b in sop_position:
-                        for i in range(pos_bound, pos_mid, -direction[pos]):
-                            write = [0,0]
-                            write[pos] = i
-                            write[sop] = b
-                            read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
-                            print("write:", write, "read:", read)
-                            inner.append([direction_idx, write, read])
-                if direction[pos] == 0: #spricht directions 1, 2, 3 und 4 an
-                    # inner: wird zwischen benachbarte Zellen *im gleichen Block* geschickt
-                    print("(inner:)")
-                    pos_low = 1
-                    pos_high = self.domain_size[pos]-1
-                    sop_position = int((self.domain_size[sop]-1)*(1+direction[sop])/2)
-                    #print("pos_low:", pos_low, "pos_high:", pos_high, "sop_position:", sop_position)
-                    for i in range(pos_low, pos_high):
-                        write = [0,0]
-                        write[pos] = i
-                        write[sop] = sop_position
-                        read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
-                        print("write:", write, "read:", read)
-                        inner.append([direction_idx, write, read])
-        # result enthält *mehrere* index arrays
-        result = list(dict.fromkeys(result)) # entferne doppelte index_arrays: speziell Ecken der Domain
-        # result ist eine liste von tuples von tuples --> [((...), (...)), ((...), (...), (...))]
-        print(result)
-        # wandel result in list_result (liste von liste von listen) um: -->[[[...], [...]], [[...], [...], [...]]]
-        list_result = [] 
-        for index_array in result:
-            list_index_array = []
-            for write_read_pair in index_array:
-                list_index_array.append(list(write_read_pair))
-            list_result.append(list_index_array)
-        
-        # zu den periodischen/parralel-orientierten index_arrays kommt noch der index array für die Werte, die nur innerhalb des Blocks verschickt werden:
-        list_result.append(inner)
-        
-        for index_array in list_result:
-            print(index_array)
-        return list_result
-                        
-                
 class SparseLbBoundaryMapper:
     NEIGHBOR_IDX_NAME = 'nidx{}'
     DIR_SYMBOL = TypedSymbol("dir", np.int64)
diff --git a/lbmpy_tests/test_sparse_lbm.ipynb b/lbmpy_tests/test_sparse_lbm.ipynb
index 2edec78b9d3ed6c17eccd3f37fc786a80a588db6..612764e22141b527cd998a2394505806f22f5fa4 100644
--- a/lbmpy_tests/test_sparse_lbm.ipynb
+++ b/lbmpy_tests/test_sparse_lbm.ipynb
@@ -53,7 +53,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "domain_size = (20,15)\n",
+    "domain_size = (5,3)\n",
     "omega = 1.8\n",
     "target = 'cpu'\n",
     "\n",
@@ -142,7 +142,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x432 with 2 Axes>"
       ]
@@ -171,15 +171,15 @@
     "    flag_arr[-1, :] = 0   \n",
     "    flag_arr[:, 0] = flags[noslip]\n",
     "    flag_arr[:, -1] = flags[noslip]\n",
-    "else:\n",
+    "#else:\n",
     "#    flag_arr[0, :] = 0\n",
     "#    flag_arr[-1, :] = 0   \n",
     "#    flag_arr[:, 0] = 0\n",
     "#    flag_arr[:, -1] = 0\n",
     "#    flag_arr[0, :] = flags[noslip]\n",
     "#    flag_arr[-1, :] = flags[density]\n",
-    "    flag_arr[:, -1] = flags[noslip]\n",
-    "    flag_arr[:, 0] = flags[noslip]\n",
+    "#    flag_arr[:, -1] = flags[noslip]\n",
+    "#    flag_arr[:, 0] = flags[noslip]\n",
     "\n",
     "def set_obstacle(size, obstacle_flag):\n",
     "    #left = domain_size[0] // size\n",
@@ -227,10 +227,21 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "flag: [[8 1 8]\n",
-      " [8 1 8]\n",
-      " [8 1 8]\n",
-      " [8 1 8]]\n"
+      "flag: [[1 1 1]\n",
+      " [1 1 1]\n",
+      " [1 1 1]\n",
+      " [1 1 1]\n",
+      " [1 1 1]]\n",
+      "dir: 0\n",
+      "dir: 1\n",
+      "dir: 2\n",
+      "dir: 3\n",
+      "dir: 4\n",
+      "dir: 5\n",
+      "dir: 6\n",
+      "dir: 7\n",
+      "dir: 8\n",
+      "number of fluid: 15 counter: 12\n"
      ]
     }
    ],
@@ -255,19 +266,6 @@
    "execution_count": 9,
    "metadata": {},
    "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[8, 1, 8],\n",
-       "       [8, 1, 8],\n",
-       "       [8, 1, 8],\n",
-       "       [8, 1, 8]], dtype=uint16)"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
     {
      "data": {
       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAF5CAYAAABtIcr0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deXRlVYGo8W8nqXkEAgVFMVQxKSiCPAUZFbUxYjeIDW032s6ziKI+pe3nsJ7DQ1tpBVGcFYX3nKc2oE9RENGntNJOTDKDVUWKGqGmJPv9cXOrklu5yR3P+P3Wcmluzkl29zr56tx99j0nxBiRJOVbT9oDkCS1z5hLUgH01b4QBod6gdOAE4EFQKizbwQ2ATcAg3Ggf6Rbg5QaEQaHZgADwPHAPKY+djcA1wE/igP9o8mMUJpcGByaDZwOHAvMYepjdx1wbRzo/8n4b+wSc+Ai4G+bGMdZwDOB85vYR+qGS4CnNbH93wNfA/61O8ORpjd2Av1p4MlN7HZOGBz6XBzov6j6woRpljA4tJzmQl71rDA4dEgL+0kdEQaHjqS5kFedHQaHlnZ6PFITnkJzIa96URgcWlz9onbO/AltDOjoNvaV2nVUG/u2c9xL7Tqyxf16gcdVv6iN+ayWh9PevlK7Zraxr8eu0tTO8bfjuJ9sznxXFzxrP+74/Wx6eytf77bXMJ/7zV1tDEDqvq9dsphrv7aI+++YyVOevZELP7My7SFJTfnhlQv4PxfvwZqVM1i0xzDn//tKnvjUzZNt2ljMAV72rtWc8cr1HRuk1G177DPMOeev4aZr57FtS73VAVI2/fLquVzxgT156ycf5HHHbeGhB6fsdeMxl/Lm1L/fBMBtv5vNmr96rCtfrvxQP2e/YQ1HnrAFgCX7DU+1eeMfGvrKh/o55+CDeMMz9uc3P57T3iglSXWNDMNdf5rN+jW9vPjo5Zx7xAoufsNebHm07jvMxmL+knc+xOdvupMv/+FOTjt3He976TLuu31GxwYuSdppzcpeRobhxh8s4EPfv5dLr72Hu/40my++f496uzQW88cfv4V5CyMzZ0dOf8kGDj1qM78cnNexgUuSdpo1p3IHxNNfspY99x1ht71GOPNVD/Pbn9btbov3ZgkR77YoSd2xaI9RdttrmND4dfvpY77h4R5u/MFctm4ODG+Hq69YwK03zeXJz3yknbFKXTe8HbZuDoyOwOgIO45hKQ+e9rz1fP/zi1mzspf1a3r47qd345hTN9XbfPor/MPbA1dc1M8HXzOLnp7IPsu38fZPP8CBh/tXoWz74vv24Bsf3znHeMP3F/K8163hZe9ek+KopMa86F/XsGFtL698ynJmzIwcN7CRf77w4XqbTx/z3ZeMcNnP7u3oIKUkvOzdhlv5NWMmXHDJai64ZHUjm3s/c0kqgNqYt3NV0yuiyiuPXaWpI8dfbcwn/cx/gx5tZyBSm9q5IO+xqzR1pLu1Mf9/tP6vxC9bHo7Uvl+1uN8I8OtODkRqUqvH7mbg5uoXE2IeB/pXAR9v4YdeHgf6H2xxQFLb4kD/ncAXW9j14jjQv67T45EaFQf6fwd8o9ndgIviQP+Os/oQJ/nwTxgcOhQ4icaeAfrzONB/S5MDkboiDA4dQRPPAI0D/XckNTZpKmFw6AnAcUz/DNC1wE/jQP89E/afLOaSpHxxaaIKL4TwjRDCJWmPQ+omz8xVaCGEfYC7qFzo3CvG6G0oVEiemavoXk5lnnEUOCflsUhd45m5CiuE0AOsBPYce+lPMcYjUhyS1DWJnZmHEHYPIVwTQnhRCGF2Ur9XpfZMYPyxdmAI4QlpDUblEUKYH0J4XQjhe0n1Lslpls3ACcDlwOoQwkUhhH0T/P0qnzdRWV5bNQs4L6WxqARCCAeFEC4DVgEXA08EtiXxuxOLeYxxM/BJKusnFwDnA3eM/ct1QghN3IVdmsbYhc+n1rzcC/xjCMGnZKljQsXfhBCuBf5A5TrNXGA7cFGMcTSJcSR9AfRjVC5EQeUsaTZwOnANcKtTMOqg6oXPWl4IVUdUp1KAe6l8gvOpVJpWfT5yAL6Q2HiSvgAaQhgETmPyTzhtovIH+AngYzHGB5Icm4phkguftbwQqpaFEA4C3gy8iEqvJnunNwx8Lsb4qqTGlcbSxA9Q/w5385k4BfN9p2DUgtoLn7W8EKqmTDGVUm/Kbjvw4aTGB+mcmQfgduCgBjaPVG7x+ABwYozxoW6OTcUQQriayru/ekaAL8QYX57QkJRjIYSDgWuBxVROOBvx8xjjSd0b1a4SPzOPlX893k9lSmU6gcpNZ3bHDzipAXUufNbyQqiaEYBFNB7yTVQal6i0AnlVg9uNAmuAY2OMq7o4HhVHvQuftbwQqobEGG+nchfZDQ3usoHKoo5EpRLzsWWKlzP1+stqyI+LMd6ZyMCUa2MXPs9j6vnyqvnAW7o7IhVFjPFm4GSmD/qjJLgccbzUPs4fQtgfuJXJ//BGgXXAkwy5GhVC+BvgP4C+BncZBY6OMf5X90alIhm7cP5L6p8wbAb2jjE2ehbfMY0e9B0XY7x37Mrws5i4THGUyjuG3YGtaYxNufVn4KuTvP5PY/99Zc3rI1TWCEuNGqZ+yIeBK9IIOaR8o60QwslUzqSqFxaqUysnU/nDBFjmenO1I4QQgVUxxr3THovyK4RwBJVliVD5mP5PgYXjNtkCPCHGeFvCQwPSXyFyPZV7GMDEOfJb2Pmv3/3ew0VSmmpC3htj/C27zqH/Jq2QQ8oxH7dMcTs1FztjjFsx6JJSNknIR2GXi6JbSWE54nhpn5lDZZni55lk1YpBl5SmeiGvGhf0T5HCcsTxcvFwihDCLCrzUeAcuprknLlaMV3IsyYLZ+bT8gxdUpLyFnLISczBoEtKRh5DDjmKORh0Sd2V15BDzmIOBl1Sd+Q55JDDmINBl9RZeQ855DTmYNAldUYRQg45jjkYdEntKUrIIecxB4MuqTVFCjkUIOZg0CU1p2ghh4LEHAy6pMYUMeRQoJiDQZc0taKGHAoWczDokiZX5JBDAWMOBl3SREUPORQ05mDQJVWUIeRQ4JiDQZfKriwhh4LHHAy6VFZlCjmUIOZg0KWyKVvIoSQxB4MulUUZQw4lijkYdKnoyhpyKFnMwaBLRVXmkEMJYw4GXSqasoccShpzMOhSURjyitLGHAy6lHeGfKdSxxwMupRXhnyi0sccDLqUN4Z8V8Z8jEGX8sGQT86Yj2PQpWwz5PUZ8xoGXcomQz41Yz4Jgy5liyGfnjGvw6BL2WDIG2PMp2DQpXQZ8sYZ82kYdCkdhrw5xrwBBl1KliFvnjFvkEGXkmHIW2PMm2DQpe4y5K0z5k0y6FJ3GPL2GPMWGHSpswx5+4x5iwy61BmGvDOMeRsMutQeQ945xrxNBl1qjSHvLGPeAQZdao4h7zxj3iEGXWqMIe8OY95BBl2amiHvHmPeYQZdmpwh7y5j3gUGXZrIkHefMe8Sgy5VGPJkGPMuMugqO0OeHGPeZQZdZWXIk2XME2DQVTaGPHnGPCEGXWVhyNNhzBNk0FV0hjw9xjxhBl1FZcjTZcxTYNBVNIY8fcY8JQZdRWHIs8GYp8igK+8MeXYY85QZdOWVIc8WY54BBl15Y8izx5hnhEFXXhjybDLmGWLQlXWGPLuMecYYdGWVIc82Y55BBl1ZY8izz5hnlEFXVhjyfDDmGWbQlTZDnh/GPOMMutJiyPPFmOeAQVfSDHn+GPOcMOhKiiHPJ2OeIwZd3WbI88uY54xBV7cY8nwz5jlk0NVphjz/jHlOGXR1iiEvBmOeYwZd7TLkxWHMc86gq1WGvFiMeQEYdDXLkBePMS8Ig65GGfJiMuYFYtA1HUNeXMa8YAy66jHkxWbMC8igq5YhLz5jXlAGXVWGvByMeYEZdBny8jDmBWfQy8uQl4sxLwGDXj6GvHyMeUkY9PIw5OVkzEvEoBefIS8vY14yBr24DHm5GfMSMujFY8hlzEvKoBeHIRcY81Iz6PlnyFVlzEvOoOeXIdd4xlwGPYcMuWoZcwEGPU8MuSZjzLWDQc8+Q656jLkmMOjZZcg1FWOuXRj07DHkmo4x16QMenYYcjXCmKsug54+Q65GGXNNyaCnx5CrGcZc0zLoyTPkapYxV0MMenIMuVphzNUwg959hlytMuZqikHvHkOudhhzNc2gd54hV7uMuVpi0DvHkKsTjLlaZtDbZ8jVKcZcbTHorTPk6iRjrrYZ9OYZcnWaMVdHGPTGGXJ1gzFXxxj06RlydYsxV0cZ9PoMubrJmKvjDPquDLm6zZirKwz6ToZcSTDm6hqDbsiVHGOuripz0A25kmTM1XVlDLohV9KMuRJRpqAbcqXBmCsxZQi6IVdajLkSVeSgG3KlyZgrcUUMuiFX2oy5UlGkoBtyZYExV2qKEHRDrqww5kpVnoNuyJUlxlypy2PQDbmyxpgrE/IUdEOuLDLmyow8BN2QK6uMuTIly0E35MoyY67MyWLQDbmyzpgrk7IUdEOuPDDmyqwsBN2QKy+MuTItzaAbcuWJMVfmpRF0Q668MebKhSSDbsiVR8ZcuZFE0A258sqYK1e6GXRDrjzrq30hDA7NAM4CTgQWAqHOvhHYCNwAfDMO9G/t1iCl8WKMW0MIs4EtVIK+LMb4QBgcmkPl2D0emE/12H3zpdA3c1EYHPpS9UcA64HrgG/Fgf4RQ640hcGh+cDzgOOAuUzd3bXAtcD34kD/juN0l5gDHwNObWIczxzb/hVN7CO1ZZegz5qzjG/f9wHg2F02PuwY6OmdMcn3TgNOCCF8BkOulITBoT7g88CRTew2ADwReFf1hQnTLGFw6BCaC3nVyWFw6PAW9pNaNmHKZb9D72d4+wlN/5BtW8+kf6khV5pOpLmQV50dBof2qH5RO2f+uDYG9Pg29p0ghFDvLYY0wY6gH/AYWHnPCoa3T/Zuc3Lbts5k9X0HcuDhYMjVhA436ogW9+sFHlv9ojbmM1seTnv7EipODCF8HVgTQljezs9TecQYt/L6D70GaDzo1ZADvPOKswy5GhVCOAZYG0L4QgjhiR34kR3pbmOrWd774r35x8ccxFkHHMxLjlnOdz61qI1fPkEIYfcQwhuBu4FBKhewZgC7d+p3qARmzx1m3xW3AxODvn6oh8veBq89uZcXPn4F13x5wYSQ73vQbfT1xbSGrVzam8pZ8QuA60MIt4QQXhFCWNCV33bPLTP4u30P4b0v3nuqzRp7S/r8Cx5m/0NXMXN25K4/zuTCs/bjkKO2cPiTW1rBMvYW5QTgjcDpwCiVK7hVI638XJVc6Insu+J2HrjzEFbes4K9D7iTj16wJ30z4CNXj7B+6K+890XL2G2vwNIVlZA7o6fWjFAJ+lzgMOAjwEdDCF8FPhZj/M+O/aaPv3UJK47YMt1mjZ2ZH3zkNmbOrpy9hBAJAR64s+m3BnXOwmczMeRS66pBB7jnlhX8+kcLOOOVMHsuHHHcCEeeFPjl1YZcnTYfmMOuZ+vz2/qpP7xyAXMXjvD44x+dbtPGPzT0kfP24sxlh/DaU5azeM9hTjh9UyO71cyFPwC8D9if8euApU6qBn3VvdDTA0v2ByKsvu9A9jsYVt7ziCFXl9Sera8em1s/uumftGldD1d9uJ9Xv/+hRjZv/Mr/BZes5vyLV/NfN8zh5uvnMGPWtPOMY2fhb6Iy/z2PxuPdA5wcQtiz4fGp3N55xRE84cSJ7/B6+x5izvzKMTQ62gvAov51bN40h82bdm57/XePDs8+f9q3sdKY42isZdWz8hcAZ4cQ7gM+HGP8dEO/5bPv6efUc9az9wHDjWzeeMwBevvg6FM28+OvLuRbn1jMOeevm2aPi6nMhzd724AFVP5Vkxrzq2tg2cETXxsZhs2PTHxt/ZrFzJoDa1Yu27nv1e9MYIQqr+rZ+iHA5cD0Mb/1pln8/hdzuey6uxv9Jc3FvGp0GP56dyNz5o8BXg+8eOzrRueP1gNPjzHe1MLoVEJhcOjlwFsnvLhgt1mMjhzAqvtgyX6V1/561yYOeOw2lh08tGO7//Glt8WB/m8nOFzlWAjhdOArQKOr+jZSuWD6CSoxn95vr5vL0IMz+OcjDwJg6+YeRkfhNSfN4hPX3zPZLtOfMa9Z2csPr1zAoxsDI8Nw4w/m8osfLOSok6adkI8x3hpjPA/YE3gl8J/AZmB7Q/8HSa3atnUmG9cewNFPhe9+GrZvG+GOm+Gma+fz9HMemXZ/qT3bqNxq4jrghcCeMcZ/iTFOGuJdnPHKdXzmV3dy6bV3c+m1d/OMf1jHUSc9wvu+fn+9XaY/Mw8BBr+4mMvfsYQ4CnvsM8yL/3U1p5zV0AVQgBjjFuAq4KoQwmG0drYuNWb8OvILPnYHF736YN50Wi/zFw1z7lv7mLtgP4a330nfjIbmIqUmTDgLbzjetebMi8yZt3OJ9ux5o8yYNcruS+ou254+5rsvGeHia+5raUCTiDHeCpwXQngr8FzgLVQ+ktpH5cNCUutqPxAUArzuIujpHWHp8juJo2HCOnSDrvZto3Jt8NfAh4H/iDF29rh62bvXTLdJavczjzFuiTFeFWM8BjiaylzSprH/zJ5yZ2kyk4W81vh16M3ey0XaaTaVs/B1VBZrPCbGeHKM8TsdD3mDamPezseaW953krn171D5YJHUmNt+u3TakFfVBv0vv98tgRGqOH4PfI+dc+EXtjydUtGR20nUxrydC0MNz6HXM+5s/R9ijNO+rZBg7AlB37zsPUDjn+wcH/TPvOtzSTwkWsUQY7w3xnh2B8/CO9Ld2pj/isrcT7MicGMbA5JasuMJQX/+dfMf0Q89kaUr/sRtv4UuPyRamsIvWtzvEeDm6hcTYh4H+oeAD7bwQz8SB/pXtTggqSUTHvX20AO9hPDxJn9EpKfnfWze1NWHREtTiQP9fwS+2ORuI8B7xj+uM8S463RNGBxays5ngE5lA3BDHOh/oMmBSG2p98zOMDi0PzufAVrx0Td9mr4ZG3jdB9887kesA34eB/pXjv28WVTWBQMsizF6TCtRYXBoOZVbBcybZtOHgevGTr537j9ZzKUsa/bhyyGECKyKMU55P2iDrjxLbWmi1IpmQ96MCc8UdcpFOWPMlRvdDHmVQVdeGXPlQhIhrzLoyiNjrsxLMuRVBl15Y8yVaWmEvMqgK0+MuTIrzZBXGXTlhTFXJmUh5FUGXXlgzJU5WQp5lUFX1hlzZUoWQ15l0JVlxlyZkeWQVxl0ZZUxVybkIeRVBl1ZZMyVujyFvMqgK2uMuVKVx5BXGXRliTFXavIc8iqDrqww5kpFEUJeZdCVBcZciStSyKsMutJmzJWoIoa8yqArTcZciSlyyKsMutJizJWIMoS8yqArDcZcXVemkFcZdCXNmKuryhjyKoOuJBlzdU2ZQ15l0JUUY66uMOQ7GXQlwZir4wz5rgy6us2Yq6MMeX0GXd1kzNUxhnx6Bl3dYszVEYa8cQZd3WDM1TZD3jyDrk4z5mqLIW+dQVcnGXO1zJC3z6CrU4y5WmLIO8egqxOMuZpmyDvPoKtdxlxNMeTdY9DVDmOuhhny7jPoapUxV0MMeXIMulphzDUtQ548g65mGXNNyZCnx6CrGcZcdRny9Bl0NcqYa1KGPDsMuhphzLULQ549Bl3TMeaawJBnl0HXVIy5djDk2WfQVY8xF2DI88SgazLGXIY8hwy6ahnzkjPk+WXQNZ4xLzFDnn8GXVXGvKQMeXEYdIExLyVDXjwGXca8ZAx5cRn0cjPmJWLIi8+gl5cxLwlDXh4GvZyMeQkY8vIx6OVjzAvOkJeXQS8XY15ghlwGvTyMeUEZclUZ9HIw5gVkyFXLoBefMS8YQ656DHqxGfMCMeSajkEvLmNeEIZcjTLoxWTMC8CQq1kGvXiMec4ZcrXKoBeLMc8xQ652GfTiMOY5ZcjVKQa9GIx5DhlydZpBzz9jnjOGXN1i0PPNmOeIIVe3GfT8MuY5YciVFIOeT8Y8Bwy5kmbQ88eYZ5whV1oMer4Y8wwz5EqbQc8PY55RhlxZYdDzwZhnkCFX1hj07DPmGWPIlVUGPduMeYYYcmWdQc8uY54Rhlx5YdCzyZhngCFX3hj07DHmKTPkyiuDni3GPEWGXHln0LPDmKfEkKsoDHo2GPMUGHIVjUFPnzFPmCFXURn0dBnzBBlyFZ1BT48xT4ghV1kY9HQY8wQYcpWNQU+eMe8yQ66yMujJMuZdZMhVdgY9Oca8Swy5VGHQk2HMu8CQSxMZ9O4z5h1myKXJGfTuMuYdZMilqRn07jHmHWLIpcYY9O4w5h1gyKXmGPTOM+ZtMuRSawx6ZxnzNhhyqT0GvXOMeYsMudQZBr0zjHkLDLnUWQa9fca8SYZc6g6D3h5j3gRDLnWXQW+dMW+QIZeSYdBbY8wbYMilZBn05hnzaRhyKR0GvTnGfAqGXEqXQW+cMa/DkEvZYNAbY8wnYcilbDHo0zPmNQy5lE0GfWrGfBxDLmWbQa/PmI8x5FI+GPTJGXMMuZQ3Bn1XpY+5IZfyyaBPVOqYG3Ip3wz6TqWNuSGXisGgV5Qy5oZcKhaDXsKYG3KpmMoe9FLF3JBLxVbmoJcm5oZcKoeyBr0UMTfkUrmUMeiFj7khl8qpbEEvdMwNuVRuZQp6YWNuyCVBeYJeyJgbcknjlSHohYu5IZc0maIHvVAxN+SSplLkoBcm5oZcUiOKGvRCxNyQS2pGEYOe+5gbckmtKFrQcx1zQy6pHUUKem5jbsgldUJRgp7LmBtySZ1UhKDnLuaGXFI35D3ouYq5IZfUTXkOem5ibsglJSGvQc9FzA25pCTlMeipxzyEsE8I4b4QwnPrfN+QS0pco0EPIbwqhPCXEML85Ea3q9RjDrweWAJ8JYRw5vhvGHJJaZou6CGEVwEfAZYCL0x4eBOEGGN6vzyEWcBqYOHYS5uBf4oxftuQq1NCCBFYFWPcO+2xKJ/GWrVl7MtlMcYHxoV87tjr9wIHxpSimvaZ+dk1Y5gDXBlC+O8YckkZMckZ+juYGHKA3YFTkx5bVWpn5iGEAPwZOGyKzQy5GhZCOB74HhBqvrXb2H+vrXl9GDgpxnhrt8emYqg5Q5/MT2KMT09qPOOleWZ+LLBsiu9vBv4uobGoGNYD86nEe/x/qmpfXwysS3iMyrcXA49O8f3jQwjLExrLBGnG/O1MfItSqzrlcuYU20g7xBj/CNzSxC7/N8a4qlvjUbFMMkc+mV7gTcmMaKJUYh5CWAqcxq5vh2sZdDXr34BNDWy3icofpjStBkMOMAN4aQhhXvdHNVFaZ+avY/qQV80BvhFCOKiL41FxfJ3Gjq1HgJ90eSwqgBDCccAnmD7k4yW+TDHxmI9dQHg9MKuBzTcBG6mcbT3YzXGpGGKMm4ErqFzcrGcz8DEvrqtBtwKfpDJX/kgD288DLhxb5JGYNM7Ma5cj1opU/h92O3AesFeM8W1jf6RSIy4Ftk/x/R7gswmNRTkXY1wbY3wtsDfwNuABpp/KS3yZYqJLE6dZjriVSsh/DHwA+EVai++VfyGEm4Ej63x7MMb47CTHo+IIIfQAzwD+BXgy0EdlrrxWossUkz4zn2w5YnUq5aPAITHG58QYbzDkalO9C6Fe+FRbYoyjMcYfxhifSuWE4TNMPgWT6DLFpM/Mv83OteOPUpkHfz/wv2OMUy3El5oSQpgDPERl/nK8VcBS58vVSSGEBcCLqCy5XkTl8w7bgU/GGN+QxBgSOzMPIewN/C0wAvyAytLEw2KMXzDk6rQ6F0K98KmuiDFujDFeCuwPPA/4GZU15y8PITSzCqZliZ2ZhxB6gVcA348x3p/IL1Wpjd2s7ddUlrdC5brMAX5QSEkIIRwCnAR8Polp41Tvmih1W82FUC98qrDSvmui1G3VC6Fe+FSheWauQhu7EDpEZcWUFz5VWMZckgrAaRZJKoC+2hfC4NAc4FzgRHY+zq2ejcDPga/Egf6p7vErdV0YHFpA5dg9nso636msA64HrowD/Vu7PTZpKmFwaDcqx+6x7PrZiFprgWuBq+JA/0j1xV1iTuXuYE9pYhzHAacAL2hiH6mjwuBQ9X4rT2hitxOo/PG8uiuDkhoQBodmAl8CDm1itxOBo4C3VF+YMM0SBocOp7mQVz0pDA7Vuw+GlIT/RnMhr3paGBxK5ckw0piTaC7kVc8Jg0N7Vb+onTN/TBsDemwb+0rtauf489hVmlo9/gLjblpYG/PJ7vzVqJlt7Cu1y2NXedXOsbtj38nmzCd67v6HTPh629bAM5+/jjd+dHUbA5C6b9uWwMVv2Is/3DiPTRt6WbLfNl749iFOeE4jDxiQ0vXAnX1c8uYl3HHzHPpmRI49bSPnfXg1fZO3f/qYf+ve23f870c3Bc49/GBOPnNjxwYsdcvwMPQvHeZ/fede9jlgmBu+P49/e91SDjz8LvZdMdWTiKT0XfLmJSzaY4Sv/PEvbFzbw4Vn7cc3L1vMOeevm2zz5taZX/u1BSzYfZijT/GpP8q+ufMjL3v3GvZdMUxPL5x0xiPsuXQbt940O+2hSdN66P4ZnHzGRmbNifQvHeGokx/h3lvrPm6zuZj/5GsLOeXMDQQ/a6QcWvPXXlbeO5Plh29LeyjStE5/6Vp+9q0FbH4ksOq+Pn533TyOeXrdKcLGq/zXu/u45aa5nPbCDR0ZqJSk7dvgA6/Yh5PP2MDyI4y5su+okzZz3+2zOPugQ3jJE1ew4nFbeOpz6z57tPGYX/PlhRx61GaWHTTVg3Kl7Bkdgfe/bB/6ZkTO/3fvZa7sGx2Bdz5/Gcc9ayPfvPt2rvzTHWxa38MnLtyz3i6Nx/xn31rEqWev78hApaTEUfjgq/dm/VAf7/7Kg8xwFaJyYP2aXh5e1cdZr13HzNmRxXuO8sznb+C3P6v7Uf/GYn7z9bNZu7qPU89xFYvy5cPnLeH+v8zkvV+9n9lzvUWo8mG3vUbo33c73758McPbYcPDPfz4qwvZ/7C69xGafmkiwI+uWsSTnrGReQv9Y1B+PHhXHz/56iL6ZkbOPeLgHa+/6n0redYLPTFRtr3jsw9y+Tv24juf2p2enshjn7yZ115U9/M9jbbHAboAAAEKSURBVMX8LZc5z6j8Wbp8mB88dFvaw5BactgxW/nI1fc1urlrDCWpAGpj3s40ilMwyiuPXaWpI8dfbczbmUd0/bnS1M7x5/y50lR37XgDdhz3tTG/ERiheaPAL9oYkNSun7e43zbgV50ciNSk61rcbyNwc/WLCTGPA/3rgHfRXNBHgP8ZB/qHWhyQ1LY40P8gcBHNHbvDwDviQL93UVRq4kD/bcClNDfdshV4exzo3/EhzhDjrvuHwaHFVB4Ht5DKDdAnHQOVfxl+GQf61zYxCKlrwuDQHlSO3XlMfeyuB26MA/1ODyoTxp4adCwwh6mP3bVUjt0J0zOTxlySlC8uTZSkAjDmklQA/x8VU7etGxUoygAAAABJRU5ErkJggg==\n",
@@ -289,8 +287,7 @@
     "                                               )\n",
     "pdf_field.field_type = FieldType.CUSTOM\n",
     "pdf_field.pdf_field_tmp = FieldType.CUSTOM\n",
-    "ps.stencil.plot_2d(stencil)\n",
-    "flag_arr"
+    "ps.stencil.plot_2d(stencil)"
    ]
   },
   {
@@ -302,94 +299,289 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "domain_size: (4, 3)\n",
+      "domain_size: (5, 3)\n",
+      "\n",
+      " New direction: (0, 1) ,  1\n",
+      "pos is  0\n",
+      "(inner:)\n",
+      "third\n",
+      "write: [1, 2] read: [1, 1]\n",
+      "write: [2, 2] read: [2, 1]\n",
+      "write: [3, 2] read: [3, 1]\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "write: [0, 0] read: [0, 2]\n",
+      "write: [1, 0] read: [1, 2]\n",
+      "write: [2, 0] read: [2, 2]\n",
+      "write: [3, 0] read: [3, 2]\n",
+      "write: [4, 0] read: [4, 2]\n",
+      "(inner:)\n",
+      "second\n",
+      "write: [0, 2] read: [0, 1]\n",
+      "write: [0, 1] read: [0, 0]\n",
+      "write: [4, 2] read: [4, 1]\n",
+      "write: [4, 1] read: [4, 0]\n",
+      "\n",
+      " New direction: (0, -1) ,  2\n",
+      "pos is  0\n",
+      "(inner:)\n",
+      "third\n",
+      "write: [1, 0] read: [1, 1]\n",
+      "write: [2, 0] read: [2, 1]\n",
+      "write: [3, 0] read: [3, 1]\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "write: [0, 2] read: [0, 0]\n",
+      "write: [1, 2] read: [1, 0]\n",
+      "write: [2, 2] read: [2, 0]\n",
+      "write: [3, 2] read: [3, 0]\n",
+      "write: [4, 2] read: [4, 0]\n",
+      "(inner:)\n",
+      "second\n",
+      "write: [0, 0] read: [0, 1]\n",
+      "write: [0, 1] read: [0, 2]\n",
+      "write: [4, 0] read: [4, 1]\n",
+      "write: [4, 1] read: [4, 2]\n",
+      "\n",
+      " New direction: (-1, 0) ,  3\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "write: [4, 0] read: [0, 0]\n",
+      "write: [4, 1] read: [0, 1]\n",
+      "write: [4, 2] read: [0, 2]\n",
+      "(inner:)\n",
+      "second\n",
+      "write: [0, 0] read: [1, 0]\n",
+      "write: [1, 0] read: [2, 0]\n",
+      "write: [2, 0] read: [3, 0]\n",
+      "write: [3, 0] read: [4, 0]\n",
+      "write: [0, 2] read: [1, 2]\n",
+      "write: [1, 2] read: [2, 2]\n",
+      "write: [2, 2] read: [3, 2]\n",
+      "write: [3, 2] read: [4, 2]\n",
+      "pos is  1\n",
+      "(inner:)\n",
+      "third\n",
+      "write: [0, 1] read: [1, 1]\n",
+      "\n",
+      " New direction: (1, 0) ,  4\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "write: [0, 0] read: [4, 0]\n",
+      "write: [0, 1] read: [4, 1]\n",
+      "write: [0, 2] read: [4, 2]\n",
+      "(inner:)\n",
+      "second\n",
+      "write: [4, 0] read: [3, 0]\n",
+      "write: [3, 0] read: [2, 0]\n",
+      "write: [2, 0] read: [1, 0]\n",
+      "write: [1, 0] read: [0, 0]\n",
+      "write: [4, 2] read: [3, 2]\n",
+      "write: [3, 2] read: [2, 2]\n",
+      "write: [2, 2] read: [1, 2]\n",
+      "write: [1, 2] read: [0, 2]\n",
+      "pos is  1\n",
+      "(inner:)\n",
+      "third\n",
+      "write: [4, 1] read: [3, 1]\n",
       "\n",
       " New direction: (-1, 1) ,  5\n",
       "pos is  0\n",
       "(periodic:)\n",
       "first\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [3, 1] read: [0, 0]\n",
+      "write: [4, 1] read: [0, 0]\n",
+      "write: [4, 2] read: [0, 1]\n",
       "(inner:)\n",
       "second\n",
+      "write: [0, 2] read: [1, 1]\n",
+      "write: [1, 2] read: [2, 1]\n",
+      "write: [2, 2] read: [3, 1]\n",
+      "write: [3, 2] read: [4, 1]\n",
       "pos is  1\n",
       "(periodic:)\n",
       "first\n",
+      "write: [0, 0] read: [1, 2]\n",
+      "write: [1, 0] read: [2, 2]\n",
+      "write: [2, 0] read: [3, 2]\n",
+      "write: [3, 0] read: [4, 2]\n",
       "(inner:)\n",
       "second\n",
-      "Read cell is a no_slip. Hmpf.\n",
+      "write: [0, 2] read: [1, 1]\n",
       "write: [0, 1] read: [1, 0]\n",
+      "(Ecke) write: [4, 0] read: [0, 2]\n",
       "\n",
       " New direction: (1, 1) ,  6\n",
       "pos is  0\n",
       "(periodic:)\n",
       "first\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [0, 1] read: [3, 0]\n",
+      "write: [0, 1] read: [4, 0]\n",
+      "write: [0, 2] read: [4, 1]\n",
       "(inner:)\n",
       "second\n",
+      "write: [4, 2] read: [3, 1]\n",
+      "write: [3, 2] read: [2, 1]\n",
+      "write: [2, 2] read: [1, 1]\n",
+      "write: [1, 2] read: [0, 1]\n",
       "pos is  1\n",
       "(periodic:)\n",
       "first\n",
+      "write: [1, 0] read: [0, 2]\n",
+      "write: [2, 0] read: [1, 2]\n",
+      "write: [3, 0] read: [2, 2]\n",
+      "write: [4, 0] read: [3, 2]\n",
       "(inner:)\n",
       "second\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [3, 1] read: [2, 0]\n",
+      "write: [4, 2] read: [3, 1]\n",
+      "write: [4, 1] read: [3, 0]\n",
+      "(Ecke) write: [0, 0] read: [4, 2]\n",
       "\n",
       " New direction: (-1, -1) ,  7\n",
       "pos is  0\n",
       "(periodic:)\n",
       "first\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [3, 1] read: [0, 2]\n",
+      "write: [4, 0] read: [0, 1]\n",
+      "write: [4, 1] read: [0, 2]\n",
       "(inner:)\n",
       "second\n",
+      "write: [0, 0] read: [1, 1]\n",
+      "write: [1, 0] read: [2, 1]\n",
+      "write: [2, 0] read: [3, 1]\n",
+      "write: [3, 0] read: [4, 1]\n",
       "pos is  1\n",
       "(periodic:)\n",
       "first\n",
+      "write: [0, 2] read: [1, 0]\n",
+      "write: [1, 2] read: [2, 0]\n",
+      "write: [2, 2] read: [3, 0]\n",
+      "write: [3, 2] read: [4, 0]\n",
       "(inner:)\n",
       "second\n",
-      "Read cell is a no_slip. Hmpf.\n",
+      "write: [0, 0] read: [1, 1]\n",
       "write: [0, 1] read: [1, 2]\n",
+      "(Ecke) write: [4, 2] read: [0, 0]\n",
       "\n",
       " New direction: (1, -1) ,  8\n",
       "pos is  0\n",
       "(periodic:)\n",
       "first\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [0, 1] read: [3, 2]\n",
+      "write: [0, 0] read: [4, 1]\n",
+      "write: [0, 1] read: [4, 2]\n",
       "(inner:)\n",
       "second\n",
+      "write: [4, 0] read: [3, 1]\n",
+      "write: [3, 0] read: [2, 1]\n",
+      "write: [2, 0] read: [1, 1]\n",
+      "write: [1, 0] read: [0, 1]\n",
       "pos is  1\n",
       "(periodic:)\n",
       "first\n",
+      "write: [1, 2] read: [0, 0]\n",
+      "write: [2, 2] read: [1, 0]\n",
+      "write: [3, 2] read: [2, 0]\n",
+      "write: [4, 2] read: [3, 0]\n",
       "(inner:)\n",
       "second\n",
-      "Read cell is a no_slip. Hmpf.\n",
-      "write: [3, 1] read: [2, 2]\n",
-      "start\n",
-      "[[5, [3, 1], [0, 0]]]\n",
-      "[]\n",
-      "[[6, [0, 1], [3, 0]]]\n",
-      "[]\n",
-      "[[7, [3, 1], [0, 2]]]\n",
-      "[]\n",
-      "[[8, [0, 1], [3, 2]]]\n",
-      "[]\n",
-      "[[5, [0, 1], [1, 0]], [6, [3, 1], [2, 0]], [7, [0, 1], [1, 2]], [8, [3, 1], [2, 2]]]\n",
-      "end\n"
+      "write: [4, 0] read: [3, 1]\n",
+      "write: [4, 1] read: [3, 2]\n",
+      "(Ecke) write: [0, 2] read: [4, 0]\n",
+      "[[1, 15, 17], [1, 18, 20], [1, 21, 23], [1, 24, 26], [1, 27, 29]]\n",
+      "[[2, 32, 30], [2, 35, 33], [2, 38, 36], [2, 41, 39], [2, 44, 42]]\n",
+      "[[3, 57, 45], [3, 58, 46], [3, 59, 47]]\n",
+      "[[4, 60, 72], [4, 61, 73], [4, 62, 74]]\n",
+      "[[5, 88, 75], [5, 89, 76]]\n",
+      "[[5, 75, 80], [5, 78, 83], [5, 81, 86], [5, 84, 89]]\n",
+      "[[5, 75, 80], [5, 78, 83], [5, 81, 86], [5, 84, 89], [5, 87, 77]]\n",
+      "[[6, 91, 102], [6, 92, 103]]\n",
+      "[[6, 93, 92], [6, 96, 95], [6, 99, 98], [6, 102, 101]]\n",
+      "[[6, 93, 92], [6, 96, 95], [6, 99, 98], [6, 102, 101], [6, 90, 104]]\n",
+      "[[7, 117, 106], [7, 118, 107]]\n",
+      "[[7, 107, 108], [7, 110, 111], [7, 113, 114], [7, 116, 117]]\n",
+      "[[7, 107, 108], [7, 110, 111], [7, 113, 114], [7, 116, 117], [7, 119, 105]]\n",
+      "[[8, 120, 133], [8, 121, 134]]\n",
+      "[[8, 125, 120], [8, 128, 123], [8, 131, 126], [8, 134, 129]]\n",
+      "[[8, 125, 120], [8, 128, 123], [8, 131, 126], [8, 134, 129], [8, 122, 132]]\n",
+      "[[1, 20, 19], [1, 23, 22], [1, 26, 25], [1, 17, 16], [1, 16, 15], [1, 29, 28], [1, 28, 27], [2, 33, 34], [2, 36, 37], [2, 39, 40], [2, 30, 31], [2, 31, 32], [2, 42, 43], [2, 43, 44], [3, 45, 48], [3, 48, 51], [3, 51, 54], [3, 54, 57], [3, 47, 50], [3, 50, 53], [3, 53, 56], [3, 56, 59], [3, 46, 49], [4, 72, 69], [4, 69, 66], [4, 66, 63], [4, 63, 60], [4, 74, 71], [4, 71, 68], [4, 68, 65], [4, 65, 62], [4, 73, 70], [5, 77, 79], [5, 80, 82], [5, 83, 85], [5, 86, 88], [5, 77, 79], [5, 76, 78], [6, 104, 100], [6, 101, 97], [6, 98, 94], [6, 95, 91], [6, 104, 100], [6, 103, 99], [7, 105, 109], [7, 108, 112], [7, 111, 115], [7, 114, 118], [7, 105, 109], [7, 106, 110], [8, 132, 130], [8, 129, 127], [8, 126, 124], [8, 123, 121], [8, 132, 130], [8, 133, 131]]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
-      "text/latex": [
-       "$\\displaystyle \\left[ \\left[ \\left[ 5, \\  \\left[ 3, \\  1\\right], \\  \\left[ 0, \\  0\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 6, \\  \\left[ 0, \\  1\\right], \\  \\left[ 3, \\  0\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 7, \\  \\left[ 3, \\  1\\right], \\  \\left[ 0, \\  2\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 8, \\  \\left[ 0, \\  1\\right], \\  \\left[ 3, \\  2\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 5, \\  \\left[ 0, \\  1\\right], \\  \\left[ 1, \\  0\\right]\\right], \\  \\left[ 6, \\  \\left[ 3, \\  1\\right], \\  \\left[ 2, \\  0\\right]\\right], \\  \\left[ 7, \\  \\left[ 0, \\  1\\right], \\  \\left[ 1, \\  2\\right]\\right], \\  \\left[ 8, \\  \\left[ 3, \\  1\\right], \\  \\left[ 2, \\  2\\right]\\right]\\right]\\right]$"
-      ],
       "text/plain": [
-       "[[[5, [3, 1], [0, 0]]], [], [[6, [0, 1], [3, 0]]], [], [[7, [3, 1], [0, 2]]], \n",
-       "[], [[8, [0, 1], [3, 2]]], [], [[5, [0, 1], [1, 0]], [6, [3, 1], [2, 0]], [7, \n",
-       "[0, 1], [1, 2]], [8, [3, 1], [2, 2]]]]"
+       "[[[1, 15, 17], [1, 18, 20], [1, 21, 23], [1, 24, 26], [1, 27, 29]],\n",
+       " [[2, 32, 30], [2, 35, 33], [2, 38, 36], [2, 41, 39], [2, 44, 42]],\n",
+       " [[3, 57, 45], [3, 58, 46], [3, 59, 47]],\n",
+       " [[4, 60, 72], [4, 61, 73], [4, 62, 74]],\n",
+       " [[5, 88, 75], [5, 89, 76]],\n",
+       " [[5, 75, 80], [5, 78, 83], [5, 81, 86], [5, 84, 89]],\n",
+       " [[5, 75, 80], [5, 78, 83], [5, 81, 86], [5, 84, 89], [5, 87, 77]],\n",
+       " [[6, 91, 102], [6, 92, 103]],\n",
+       " [[6, 93, 92], [6, 96, 95], [6, 99, 98], [6, 102, 101]],\n",
+       " [[6, 93, 92], [6, 96, 95], [6, 99, 98], [6, 102, 101], [6, 90, 104]],\n",
+       " [[7, 117, 106], [7, 118, 107]],\n",
+       " [[7, 107, 108], [7, 110, 111], [7, 113, 114], [7, 116, 117]],\n",
+       " [[7, 107, 108], [7, 110, 111], [7, 113, 114], [7, 116, 117], [7, 119, 105]],\n",
+       " [[8, 120, 133], [8, 121, 134]],\n",
+       " [[8, 125, 120], [8, 128, 123], [8, 131, 126], [8, 134, 129]],\n",
+       " [[8, 125, 120], [8, 128, 123], [8, 131, 126], [8, 134, 129], [8, 122, 132]],\n",
+       " [[1, 20, 19],\n",
+       "  [1, 23, 22],\n",
+       "  [1, 26, 25],\n",
+       "  [1, 17, 16],\n",
+       "  [1, 16, 15],\n",
+       "  [1, 29, 28],\n",
+       "  [1, 28, 27],\n",
+       "  [2, 33, 34],\n",
+       "  [2, 36, 37],\n",
+       "  [2, 39, 40],\n",
+       "  [2, 30, 31],\n",
+       "  [2, 31, 32],\n",
+       "  [2, 42, 43],\n",
+       "  [2, 43, 44],\n",
+       "  [3, 45, 48],\n",
+       "  [3, 48, 51],\n",
+       "  [3, 51, 54],\n",
+       "  [3, 54, 57],\n",
+       "  [3, 47, 50],\n",
+       "  [3, 50, 53],\n",
+       "  [3, 53, 56],\n",
+       "  [3, 56, 59],\n",
+       "  [3, 46, 49],\n",
+       "  [4, 72, 69],\n",
+       "  [4, 69, 66],\n",
+       "  [4, 66, 63],\n",
+       "  [4, 63, 60],\n",
+       "  [4, 74, 71],\n",
+       "  [4, 71, 68],\n",
+       "  [4, 68, 65],\n",
+       "  [4, 65, 62],\n",
+       "  [4, 73, 70],\n",
+       "  [5, 77, 79],\n",
+       "  [5, 80, 82],\n",
+       "  [5, 83, 85],\n",
+       "  [5, 86, 88],\n",
+       "  [5, 77, 79],\n",
+       "  [5, 76, 78],\n",
+       "  [6, 104, 100],\n",
+       "  [6, 101, 97],\n",
+       "  [6, 98, 94],\n",
+       "  [6, 95, 91],\n",
+       "  [6, 104, 100],\n",
+       "  [6, 103, 99],\n",
+       "  [7, 105, 109],\n",
+       "  [7, 108, 112],\n",
+       "  [7, 111, 115],\n",
+       "  [7, 114, 118],\n",
+       "  [7, 105, 109],\n",
+       "  [7, 106, 110],\n",
+       "  [8, 132, 130],\n",
+       "  [8, 129, 127],\n",
+       "  [8, 126, 124],\n",
+       "  [8, 123, 121],\n",
+       "  [8, 132, 130],\n",
+       "  [8, 133, 131]]]"
       ]
      },
      "execution_count": 10,
@@ -499,13 +691,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "domain: (4, 3)\n",
-      "pdf size in bytes: 288\n",
-      "pdf size: 36\n",
-      "index array size in bytes: 64\n",
+      "domain: (5, 3)\n",
+      "pdf size in bytes: 1080\n",
+      "pdf size: 135\n",
+      "index array size in bytes: 96\n",
       "density index array size in bytes: 0\n",
       "ubb index array size in bytes: 0\n",
-      "sum: 352\n"
+      "sum: 1176\n"
      ]
     }
    ],
@@ -664,7 +856,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.quiver.Quiver at 0x7faf4a2b9910>"
+       "<matplotlib.quiver.Quiver at 0x7f52e08f38e0>"
       ]
      },
      "execution_count": 20,
@@ -673,7 +865,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6gAAAFlCAYAAADmqMVrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3hVVcL+/Xul0IO0AAl9EBEEgRCaqLSRAVSajIAmiDoiAUSQYcQHH8EZuo40qSIqolL8ITqgYH0AYQQSmiigCEEQFJQWesp6/yDwJuSc5CQ5LTnfz3XlImevtfe+c3lAbvY+axtrrQAAAAAA8LUgXwcAAAAAAECioAIAAAAA/AQFFQAAAADgFyioAAAAAAC/QEEFAAAAAPgFCioAAAAAwC+E+DqAIxUqVLA1a9b0dQwgYFlr9e233yo5OdnhePXq1RUeHi5JunLlivbs2aOUlBSVLFlSt956qzejAi47d+6c9u3b57Hjh4aGuvRljPFYBgAACoKEhITfrbXhjsb8sqDWrFlT8fHxvo4BBKzFixcrNjbW4Vi5cuW0Z88elShR4vq2TZs2qV27drrvvvu0ZMkSb8UEcu3ll1/WyJEjPXLs5ORkp/+oExERoTFjxuixxx5TaGioR84PAEBBYYw55GyMW3wBZGKt1dSpU52ODxw4MFM5laQ77rhD8+fPV40aNTwdD8iXESNGqGfPnl47X9myZTV58mTt379fTz75JOUUAIAc+OUVVAC+s2HDBm3bts3hWGhoqAYPHuxw7JFHHtGxY8c8GQ3Il5SUFO3du1dt27bVBx98IGutx85VokQJDRs2TCNHjlSZMmU8dh4AAAobCiqATKZNm+Z0rHfv3oqMjHQ6HhER4YlIQK4lJyfru+++07Zt27Rt2zYlJCRo586dunjxokfPGxoaqieffFKjR49W5cqVPXouAAAKIwoqgOsOHDiglStXOh0fNmyYF9MArrl8+bJ2796thISE62V0165dunLlitcyGGMUGxursWPHqlatWl47LwAAhQ0FFcB1M2bMcHrb41133aWmTZt6ORGQ2cWLF7Vr167rZXTbtm3avXu308WJvKFbt24aN26cGjRo4LMMAAAUFhRUAJKkM2fO6PXXX3c6Pnz4cC+mAa4+Fmbnzp2Zyuj333+v1NRUX0eTJLVt21YTJ05Uy5YtfR0FAIBCg4IKQJK0cOFCnTt3zuFYrVq11LVrVy8nQiA5c+aMduzYkamM7t2716MLGeVV06ZNNWHCBN1zzz080xQAADejoAJQamqqZsyY4XR86NChCg4O9mIiFGanTp3KtHjRtm3b9OOPP/o6Vo7q1q2rcePG6YEHHqCYAgDgIRRUAFq5cqUSExMdjoWFhemxxx7zbiAUGidOnMhSRg8ePOiTLHXq1FFUVJSioqLUtGlTjRkzRhs3bsxxv6pVq2rs2LF65JFHFBLC/zYBAPCkHP9Pa4ypJmmRpMqS0iTNt9ZOv2GOkTRdUhdJFyT1t9ZuSx/rlD4WLGmBtXaSW38CAPk2depUp2N/+9vfVLp0aS+mQWHRp08fLV261OvnNcaobt26atq06fUy2rhxY910003X51y6dMnp836vKV++vEaPHq24uDgVK1bM07Hhgs8//1xz5sxR06ZNr//3DQ8P92mmpKQkhYaG8h4BADdx5Z+CUySNsNZuM8aESUowxnxmrf0+w5zOkuqkf7WQNEdSC2NMsKRZku6RdETSVmPMRzfsC8CHtm7d6vQqUlBQkJ566ikvJ0JhUa1aNY+fIygoSPXr189URhs1aqRSpUplu9/XX3/t9JmopUqV0ogRI/TMM8/wjzN+Zt26dVqxYoVWrFhxfVu1atWuF9Zr74NKlSp5LVNaWppuu+02Pf/884qNjeUqOwDkU45/ilprj0k6lv59kjFmj6QqkjKWzG6SFtmrq1l8Y4wpY4yJkFRT0n5r7QFJMsYsSZ9LQQX8RJUqVTRixAi99tprOnv2bKax7t2780xH5FlUVJRbjxcSEqIGDRpkKqMNGzZUiRIlcn2stWvXZtlWpEgRDR48WM8995zPr8rBsYSEhCzbDh8+rMOHD2d6hnOVKlUyFdamTZsqIiLCI5luuukmRURE6LHHHtNLL72k8ePHq3v37nxOuYA4ceKE5s6dq8uXL2vcuHG+jgNAksnNConGmJqS1ktqYK09m2H7KkmTrLVfp7/+QtKzulpQO1lr/5a+PVZSC2vtEAfHHiBpgCRVr1696aFDh/L2EwHIk6SkJL355puaPn26fvrpJ0nShg0bdOedd/o4GQqqH374QXXr1s3TvkWKFNHtt99+vVxERUWpYcOGKlq0qFuyNWrUSLt27ZJ09Sps//79NWbMGFWvXt0tx4f7WWtVuXJlHT9+PE/7R0REZCmtkZGRbimS//znPzVmzJjrr5s3b66JEyeqffv2+T42POP777/XtGnT9Pbbb+vSpUsqXry4fv75Z1WoUMHX0YCAYIxJsNZGOxxztaAaY0pJWidpvLV2xQ1jqyVNvKGg/kPSnyT95YaC2txam+09g9HR0TY+Pt6lXADcKzU1VatXr9batWv16quvchUAeZaWlqYyZcooKSkp23nFihVT48aNM5XR2267TaGhoR7JdezYMUVGRkqSevXqpX/961+69dZbPXIuuM+RI0fcftt4pUqVspTWqlWr5vrPvW+++UatWrXKsv2ee+7RhAkTFB3t8O9g8IGNGzdq/Pjx+uSTT7KMjRs3TqNHj/ZBKiDw5LugGmNCJa2StNZa+4qD8XmS/s9a+176632S2urqFdSx1tq/pG9/TpKstROzOx8FFQAKhzZt2mj9+vXXX5csWVJNmjTJVEZvvfVWr35ub9GiRVq8eDHFoYD56KOP1K1bN4+fJzw8PEtprV69eralNTU1VRUqVNDp06cdjvMPIf5j7ty5iouLczhWuXJlJSYmuu1ODQDO5augpq/Q+5akk9baYU7m3CtpiK6u4ttC0gxrbXNjTIikHyR1kPSLpK2SHrLWfpfdOSmoAFA4zJkzR/v377/+F/06der4/Jm6f/zxh8qXL+/TDMi9BQsWaNiwYTp//rzXz12+fPlMhbVp06aqWbNmptL617/+Ve+//77TYwQFBenRRx/VmDFjvLKAGBy7cOGCqlWrppMnTzocf/PNN/XII494ORUQePJbUO+UtEHSt7r6mBlJ+h9J1SXJWjs3vcS+KqmTrj5m5lFrbXz6/l0kTdPVx8wstNaOzykwBRUAANwoNTVVP/74oxISEq4/V3fbtm053kbuCeXKlcv0XN1vv/3WpUV2ihYten0xLj7v6BvPP/+8xo93/NfRRo0aafv27Xy8BfAwt3wG1ZsoqAAAwBVpaWnav3//9cJ67dczZ874Olq2wsLCNHLkSA0fPjzHxyLBvY4dO6YaNWooOTnZ4fgXX3zBAleAh1FQAQBAwEhLS9OBAweuF9ZrpfXUqVO+jpZFeHi4nn/+eT355JN89tGL+vfvr7feesvh2L333qtVq1Z5OREQWCioAAAgoFlrlZiYeL2wXvty9llEb6tRo4ZefPFFxcTE+Pxz2oFg586daty4sdPxPXv2sKgV4EEUVAAAgBtYa/Xzzz9nKa2///67zzLVr19f48ePV7du3fgcpId16NBBX375pcOxgQMHas6cOV5OBAQOCioAAIALrLU6cuRIpluDExIS9Ntvv3k1R4sWLTRp0iS1bdvWq+cNJKtXr9Z9993ncKx48eL6+eefWcgK8BAKKgAAQB5Za3X06NFMhTUhIUHHjh3z+Lk7duyoCRMmqGnTph4/V6BJS0tT/fr1tW/fPofj48aN0+jRo72cCggMFFQAAAA3O3bsmLZt26YhQ4YoMTHRo+f661//qn/961+qW7euR88TaObNm6eBAwc6HKtcubISExOdLl51+vRplSlTxpPxgEIru4Ia5O0wAAAAhUFERISOHz/u8XIqScuXL9dtt92mAQMG6MiRIx4/X6CIjY1VuXLlHI79+uuvWrJkicOx+fPn6+233/ZkNCBgUVABAADyYPv27Ro0aJDXzpeamqrXXntNN998s0aOHKk//vjDa+curEqUKKG4uDin41OnTtWNdxuuW7dOgwcP1sGDBz0dDwhIIb4OAAAAUNCcOnVKvXr10qVLlzxy/LJlyyoiIkKVK1d2+GtERISKFCnikXMHmsGDB2vKlClKTk7OMrZz50599dVXat++vSTp4MGDeuCBB5SSkuKVK+dAIKKgAgAA5EJaWpr69eunAwcO5Gq/kJAQVapUKUvRvLF8VqpUScWKFfNQetwoIiJCDz30kN566y2H46+88orat2+vpKQkde3a9fqVa66gAp5BQQUAAMiFSZMmadWqVddfh4WF5Xi1s3LlyipfvryCgvh0lT8aPny404K6evVq7dmzR88995x27959fTsFFfAMCioAAICLkpOTVa9ePW3YsOF68SxZsqSvYyGfGjVqpPbt2+vLL790OP7nP/9ZR48ezbTtzJkzrOQLeAD/jAcAAOCi0NBQ9ejRQ3feeadq165NOS1EnnnmGadjN5bTa7iKCrgfBRUAAAABwVqr3bt366efftJvv/2m8+fPKy0tTZLUuXPnXD9nloIKuB8FFQAAAAHBGKPPPvtMN998sypXrqxSpUopODhYpUqVUkRERK6fMctKvoD7UVABAAAQMIYNG5bl+bXnz5/X8ePHdf78+VwdiyuogPtRUAEAABAwjDGaPn26OnfunO9jcQUVcD8KKgAAAAJKSEiIli5dqttvvz1fx+EKKuB+FFQAAAAEnLCwMK1evVqRkZF5PsbBgwdlrXVjKgAUVAAAAASkqlWr6j//+U+eHxd04cIF/f77725OBQQ2CioAAAACVlRUlJYsWaKgoLz9tZjbfAH3oqACAAAgoN13332aNm1anvaloALuRUEFAABAwHvqqac0dOjQXO/HSr6Ae1FQAQAAAEmvvPKK7r///lztwxVUwL0oqAAAAICk4OBgvfvuu2rSpInL+1BQAfeioAIAAADpSpUqpVWrVqlq1aouzecWX8C9KKgAAABABpGRkVq1apVKlSqV49zExESlpaV5IRUQGCioAAAAwA0aNWqkZcuW5fj4mStXrujYsWNeSgUUfjkWVGPMQmPMcWPMbifjI40xO9K/dhtjUo0x5dLHEo0x36aPxbs7PAAAAOApnTt31quvvprjPG7zBdzHlSuob0rq5GzQWvuStbaxtbaxpOckrbPWnswwpV36eHT+ogIAAADeFRcXp2eeeSbbOSyUBLhPjgXVWrte0smc5qXrK+m9fCUCAAAA/MiUKVPUvXt3p+MUVMB93PYZVGNMCV290vr/Mmy2kj41xiQYYwa461wAAACAtwQHB2vx4sWKjnZ8QyC3+ALu485Fku6XtPGG23tbW2ujJHWWNNgYc7eznY0xA4wx8caY+BMnTrgxFgAAAJA/JUuW1H/+8x9Vr149yxhXUAH3cWdB7aMbbu+11h5N//W4pA8kNXe2s7V2vrU22lobHR4e7sZYAAAAQP5VrlxZq1evVunSpTNtp6AC7uOWgmqMuUlSG0kfZthW0hgTdu17SR0lOVwJGAAAACgIGjRooOXLlys4OPj6tsOHDyslJcWHqYDCw5XHzLwn6b+S6hpjjhhjHjfGDDTGDMwwrYekT6215zNsqyTpa2PMTklbJK221q5xZ3gAAADA2zp27Kg5c+Zcf52amqojR474MBFQeITkNMFa29eFOW/q6uNoMm47IKlRXoMBAAAA/uqJJ57Q/v37NWXKFElXF0qqWbOmb0MBhYA7P4MKAAAABIyJEyfqgQcekMTnUAF3yfEKKgAAAICsgoKC9Pbbb+vIkSMUVMBNuIIKAAAA5FHx4sX14Ycfyhjj6yhAoUBBBQAAAPKhUqVKGjVqlK9jAIUCBRUAAADIp+LFi/s6AlAoUFABAAAAAH6BggoAAAAA8AsUVAAAAACAX6CgAgAAAAD8AgUVAAAAAOAXKKgAAAAAAL9AQQUAAAAA+AUKKgAAAADAL1BQAQAAAAB+gYIKAAAAAPALFFQAAAAAgF+goAIAAAAA/AIFFQAAAADgFyioAAAAAAC/QEEFAAAAAPgFCioAAAAAwC9QUAEAAAAAfoGCCgAAAADwCxRUAAAAAIBfoKACAAAAAPwCBRUAAAAA4BcoqAAAAAAAv0BBBQAAAAD4hRwLqjFmoTHmuDFmt5PxtsaYM8aYHelfL2QY62SM2WeM2W+MGeXO4AAAAACAwsWVK6hvSuqUw5wN1trG6V//lCRjTLCkWZI6S6ovqa8xpn5+wgIAAAAACq8cC6q1dr2kk3k4dnNJ+621B6y1VyQtkdQtD8cBAAAAAAQAd30GtZUxZqcx5hNjzG3p26pIOpxhzpH0bQAAAAAAZBHihmNsk1TDWnvOGNNF0kpJdSQZB3Ots4MYYwZIGiBJ1atXd0MsAAAAAEBBku8rqNbas9bac+nffywp1BhTQVevmFbLMLWqpKPZHGe+tTbaWhsdHh6e31gAAAAAgAIm3wXVGFPZGGPSv2+efsw/JG2VVMcYU8sYU0RSH0kf5fd8AAAAAIDCKcdbfI0x70lqK6mCMeaIpDGSQiXJWjtXUi9JccaYFEkXJfWx1lpJKcaYIZLWSgqWtNBa+51HfgoAAAAAQIFnrnZJ/xIdHW3j4+N9HQMAAAAA4GbGmARrbbSjMXet4gsAAAAAQL5QUAEAAAAAfoGCCgAAAADwCxRUAAAAAIBfoKACAAAAAPwCBRUAAAAA4BcoqAAAAAAAv0BBBQAAAAD4BQoqAAAAAMAvUFABAAAAAH6BggoAAAAA8AsUVAAAAACAX6CgAgAAAAD8AgUVAAAAAOAXKKgAAAAAAL9AQQUAAAAA+AUKKuBH0tLSdPbsWV/HAAAAAHyCggr4kaCgIMXFxenYsWO+jgIAAAB4HQUV8DPlypXTHXfcoR9++MHXUQAAAACvoqACfqZ9+/ZKTExU69attXXrVl/HAQAAALyGggr4mbZt28oYo99//11t27bVmjVrfB0JAAAA8AoKKuBnypYtq6ioKEnShQsXdP/992vRokU+TgUAAAB4HgUV8EMdOnS4/n1KSooeeeQRTZkyRdZaH6YCAAAAPIuCCvihjAX1mmeffVbPPPOM0tLSfJAIAAAA8DwKKuCHWrdurdDQ0Czbp02bpocffliXL1/2QSoAAADAsyiogB8qWbKkWrVq5XBsyZIluvfee3X27FkvpwIAAAA8i4IK+ClHt/le88UXX6ht27b69ddfvZgIAAAA8CwKKuCn2rdvn+349u3bdccdd+jHH3/0UiIAAADAs3IsqMaYhcaY48aY3U7GHzbG7Er/2mSMaZRhLNEY860xZocxJt6dwYHCrnnz5ipZsmS2cw4ePKjWrVsrPp7fXgAAACj4XLmC+qakTtmMH5TUxlp7u6R/SZp/w3g7a21ja2103iICgalIkSK6++67c5x34sQJtW3bVp9++qkXUgEAAACek2NBtdaul3Qym/FN1tpT6S+/kVTVTdmAgJfTbb7XnD9/Xvfee6/eeecdDycCAAAAPMfdn0F9XNInGV5bSZ8aYxKMMQPcfC6g0MtuoaQbpaSkKCYmRv/+9789mAgAAADwHLcVVGNMO10tqM9m2NzaWhslqbOkwcYYp/crGmMGGGPijTHxJ06ccFcsoEBr1KiRypUrl6t9/v73v2vEiBFKS0vzUCoAAADAM9xSUI0xt0taIKmbtfaPa9uttUfTfz0u6QNJzZ0dw1o731obba2NDg8Pd0csoMALCgpSu3btcr3fK6+8otjYWF25csUDqQAAAADPyHdBNcZUl7RCUqy19ocM20saY8KufS+poySHKwEDcC43t/lm9O677+q+++5TUlKSmxMBAAAAnuHKY2bek/RfSXWNMUeMMY8bYwYaYwamT3lBUnlJs294nEwlSV8bY3ZK2iJptbV2jQd+BqBQc3WhJEc+++wztWvXTr/99psbEwEAAACeYay1vs6QRXR0tOW5jsBV1lpVq1ZNv/zyS56PUbt2ba1du1a1a9d2YzJ4W3JyskaPHq2GDRuqR48eKlWqlK8jAQAA5JoxJsHZY0jdvYovADczxuT5Nt9rfvrpJ91xxx3atm2bm1LBF0JDQ/X4448rLi5OlSpVUkxMjNauXauUlBRfRwMAAHALCipQAOTnNt9rjh8/rjZt2uizzz5zQyL4St26dTVv3jxduHBB77zzjjp16qRq1arpmWee0bZt2+SPd8UAAAC4ioIKFADuKKiSdO7cOd17771699133XI8+MbDDz+sxx9//PrrX3/9VVOnTlXTpk3VoEEDTZo0ST///LMPEwIAAOQNn0EFCohbbrlFP/74o8vz69evr44dO6pixYoKDw/P9FWxYkXddNNNHkwLT7tw4YJatGih3budL47etm1bxcTEqFevXvz3BgAAfiO7z6BSUIECIi4uTnPnznV5fsWKFbVv3z6VKVPGg6ngS3v27FF0dLQuXLiQ7bxixYqpa9euiomJUadOnRQaGuqlhAAAAFmxSBJQCOR2oaTjx4/rf//3fz2UBv6gXr16mj17do7zLl26pGXLlqlr166KjIzUkCFDtHnzZj6vCgAA/A5XUIEC4vfff1d4eHiu9gkKCtLWrVsVFRXloVTwB/3799dbb72V6/3q1KmjmJgYxcTE6E9/+pMHkgEAAGTFFVSgEKhQoYIaN26cZfvgwYMVFhbmcJ+0tDTFxcUpLS3N0/HgQ7NmzdKtt96a6/1+/PFHjRkzRrVr11br1q01d+5cnTx50gMJAQAAXENBBQqQG2/zrVevnv7973/rn//8p9N9tmzZogULFng6GnyoZMmSWrZsmYoVK5bnY2zatElxcXGqXLmyevTooRUrVujy5ctuTAkAAJAzCipQgNz4uJl58+apaNGiGjJkiG6//Xan+40aNUonTpzwdDz4UMOGDTVz5sx8Hyc5OVkrV67UAw88oMqVK+vJJ5/U119/zVV4AADgFRRUoAC5++67FRISIkn629/+prvuukuSFBISku1iOadOndKoUaO8khG+8/jjj+uhhx5y2/FOnz6t+fPn66677lLt2rX1v//7v/rpp5/cdnwAAIAbUVCBAqRUqVJq0aKFKlasqClTpmQaa926tR599FGn+y5cuFAbN270dET4kDFGc+fO1S233OL2Y//xxx8KCgpS+fLl3X5sAACAayioQAHTvn17TZs2TWXLls0yNnnyZIfbrxk0aJBSUlI8GQ8+FhYWpmXLlqlo0aJuOV6pUqX0P//zP0pMTNSLL77Ic3UBAIBHUVCBAmbQoEHq06ePw7Hw8HBNmjTJ6b67du3Sq6++6qlo8BONGjXStGnT8nWMEiVK6Nlnn9XBgwc1fvx4lStXzk3pAAAAnOM5qEAhk5aWplatWmnLli0Ox8PCwrR3715FRkZ6ORm8yVqrPn36aNmyZXnaf9asWRo0aJCbUwEAAPAcVCCgBAUFafbs2QoKcvzbOykpSSNGjPByKnibMUavvfaaateunaf9Bw8erEGDBunSpUtuTgYAAOAcBRUohJo2baq4uDin40uWLNEXX3zhxUTwhdKlS2vZsmUqUqRInvafM2eOWrZsqX379rk5GQAAgGMUVKCQGjdunCpWrOh0fPDgwbp8+bIXE8EXoqKi9O9//zvP++/cuVNNmzbV4sWL3ZgKAADAMQoqUEiVKVNGL7/8stPxffv25au4oOAYPHiwevbsmef9z58/r9jYWD322GM6f/68G5MBAABkRkEFCrGYmBjdfffdTsfHjRunxMRE7wWCTxhj9Prrr6tWrVpOx7N7PNE1b7zxhpo1a6bdu3e7OyIAAIAkCipQqBljNHv2bIWEhDgcv3jxop5++mkvp4IvlClTRkuXLlVoaGiWsdq1a2vHjh1q1apVjsfZs2ePmjVrpgULFsgfV4EHAAAFGwUVKORuu+02DR8+3On4Rx99pP/85z9eTARfadasmaZMmZJl++23367q1atr3bp1GjVqVI7HuXTpkp544gnFxMQoKSnJE1EBAECAoqACAeCFF15Q1apVnY4PHTpUFy5c8GIi+MrTTz+tbt26ZdrWsGFDSVJoaKgmTpyoTz75ROHh4Tke691331VUVJS2b9/ukawAACDwUFCBAFCqVClNmzbN6XhiYqImTJjgxUTwFWOMFi5cqOrVq1/fdq2gXtOpUyft2LFDbdu2zfF4+/fvV8uWLTVr1ixu+QUAAPlGQQUCRM+ePdWpUyen4y+99BLPuwwQ5cqV05IlS65/NvnGgipJkZGR+vzzzzV27FgZY7I93pUrVzRkyBD16tVLp0+f9khmAAAQGCioQIAwxmjmzJkqWrSow/FrJYOrYIGhVatWmjBhgooXL67atWs7nBMcHKwxY8boiy++UERERI7HXLFihZo0aaLNmze7Oy4AAAgQFFQggNx8883ZLoLz+eefa/ny5V5MBF8aMWKE/vGPfyg4ODjbee3atdOOHTvUsWPHHI+ZmJioO++8Uy+//LLS0tLcFRUAAAQI449XS6Kjo218fLyvYwCF0sWLF9WwYUP99NNPDscjIyO1d+9ehYWFeTkZfMFam+MtvNekpaVpypQpev7555Wamprj/C5duuitt95ShQoV8hsTAAAUIsaYBGtttKOxHK+gGmMWGmOOG2McPpndXDXDGLPfGLPLGBOVYayTMWZf+ljOzy4A4HHFixfXzJkznY4fPXpUY8eO9V4g+JSr5VSSgoKCNGrUKK1bt07VqlXLcf7HH3+sxo0ba/369fmJCAAAAogrt/i+Kcn5yipSZ0l10r8GSJojScaYYEmz0sfrS+prjKmfn7AA3KNz587q2bOn0/Hp06dr165dXkyEgqR169bavn277r///hzn/vLLL/rqq6+8kAqFUUpKikaPHp3tKuRAbvjjnYMAMsuxoFpr10s6mc2UbpIW2au+kVTGGBMhqbmk/dbaA9baK5KWpM8F4AemTZumEiVKZNkeHBysp556SjVr1vR+KBQY5cuX14cffqipU6cqNDTU6bx27drp+eef92IyFBZHjhxR+/btNWHCBP3jH//Qli1bfB0JBVxKSmu+eWsAAB+iSURBVIo6dOigOXPmuPQxBQC+4Y5FkqpIOpzh9ZH0bc62A/AD1apV05gxYzJtu+OOO5SQkKCpU6eqdOnSPkqGgsIYo2HDhmnjxo2qVatWlvHw8HC98847OS7CBNzok08+UePGjbVhwwZJUnJysh588EGdOnXKx8lQkM2ePVtfffWVBg0apJYtW2rr1q2+jgTAAXcUVEcfYLLZbHd8EGMGGGPijTHxJ06ccEMsADkZNmyY6tWrpwoVKmjhwoXasGGDGjVq5OtYKGCaNWum7du3q1evXpm2L1682KXH0wDXJCcna9SoUerSpYv++OOPTGOHDh3SY489xi2ayJNjx45lupsjPj5eLVq00KBBg/iHD8DPuKOgHpGUcbWMqpKOZrPdIWvtfGtttLU2Ojw83A2xAOSkSJEiWr58ufbt26dHH31UQUE8eQp5c9NNN2nZsmWaM2eOihYtqueee86lx9IA1xw+fFht27bV5MmTnc5ZuXJltou8Ac78/e9/V1JSUqZt1lrNmTNH9evX19mzZ32UDMCN3PG30Y8k9UtfzbelpDPW2mOStkqqY4ypZYwpIqlP+lwAfuS2225TuXLlfB0DhYAxRgMHDtT27dv14osv+joOCpBVq1apcePG2rRpU45zFy1apJSUFC+kQmHx5Zdf6t1333U63qNHDz7WAvgRVx4z856k/0qqa4w5Yox53Bgz0BgzMH3Kx5IOSNov6TVJgyTJWpsiaYiktZL2SFpmrf3OAz8DAMCP1KtXL9uFk4BrkpOTNXLkSN1///06eTK79RiveuKJJ7RhwwaFhIR4IR0KgytXrmjw4MFOx8PDwzV+/HgvJgKQkxz/hLfW9s1h3Epy+DvfWvuxrhZYAABQyB09elSRkZEuzT106JD69Omjb775Jse5pUqV0vz589W3b7Z/JQGyeOWVV7R3716n4y+99JLKli3rxUQAcsIHzgAAQL5dvHhRXbp00blz53Kc++GHH6pJkyYuldNGjRopISGBcopcO3TokP75z386Hb/rrrvUr18/LyYC4AoKKgAAyLfhw4dr586d+u4755/muXLlioYPH67u3bu7tHJqXFycvvnmG91yyy3ujIoA8fTTT+vixYsOx4KDgzV79mwZ4+ihEwB8iYIKAADyZdmyZZo3b54kadeuXQ7nHDx4UHfeeaemTZuW4/HCwsK0dOlSzZ49W8WKFXNrVgSGVatW6cMPP3Q6PmzYMDVo0MCLiQC4ilUGAABAnv3000964oknrr92VFA/+OADPfroozpz5kyOx4uKitLSpUt18803uzUnAseFCxf01FNPOR2vUqWKxowZ48VEAHKDK6gAACBPLl++rN69e2d6hmTGgnr58mUNHTpUPXv2dKmcDhkyRJs2baKcIl8mTpyoxMREp+PTpk1TWFiY9wIByBWuoAIAgDwZNWqUEhISMm3btWuXrLU6cOCAevfunWXckdKlS2vhwoV64IEHPBUVAeKHH37QlClTnI537NiR9xng57iCCgAAcu2jjz5y+HnS06dPa8aMGYqKinKpnEZHR2v79u2UBuSbtVaDBw/WlStXHI4XKVJEr776KgsjAX6OggoAAHLl559/Vv/+/Z2ODxs2LNNtv848/fTT+vrrr/WnP/3JjekQqJYvX67PP//c6fioUaNUp04dLyYCkBfc4gsAAFyWnJysvn37uvSYGGfKlCmjN954Q927d3djMgSypKQkDR8+3Ol4rVq1NGrUKC8mApBXFFQAAOCyMWPGaNOmTXnev3nz5lq6dKlq1qzpvlAIeGPHjtXRo0edjr/66qsqXry4FxMByCtu8QUAAC759NNPNWnSpDzv/8wzz2jDhg2UU7jVt99+q+nTpzsd7969u7p06eLFRADygyuoAAAgR8eOHVNsbKystbnet2zZsnrrrbd0//33eyAZAllaWpri4uKUmprqcLxEiRIOF/MC4L+4ggoAALKVmpqqmJgYHT9+PE/7d+jQQVFRUW5OBUiLFi3Sxo0bnY6/8MILqlGjhhcTAcgvCioAAMjWxIkT9eWXX+Z5//fff1+1a9fW0KFDs/2cIHCjNWvWOB07efKk/vGPfzgdr1evXrYLJwHwTxRUAADg1Pr16zVmzJh8H+fy5cuaOXOmateurWHDhunYsWNuSIfC7MqVK+rdu7e2b9/ucHz06NE6ceKE0/1nzZqlIkWKeCoeAA+hoAIAAIdOnDihvn37Ki0tzW3HvHTpkqZPn67atWtr6dKlbjsuCp/Nmzfr7NmzGjBgQJbPmG7dulXz5s1zuu/DDz+sdu3aeToiAA+goAIAgCzS0tLUv39/t9+SW6tWLb3wwgvauXOnevfu7dZjo3C5dlt5fHy8Zs2adX17amqq4uLinC7YVbp0ab388steyQjA/VjFFwAAZDF16lR9/PHHbjnWTTfdpAcffFD9+vVT69atZYxxy3FRuH3xxRfXvx89erR69OihatWqad68eUpISHC637hx41S5cmVvRATgASYvy8V7WnR0tI2Pj/d1DAAAAtLmzZt15513KiUlJc/HCAkJUefOndWvXz/dd999KlasmBsTorA7f/68ypYtq+Tk5OvbunXrpnnz5qlu3bo6c+aMw/2aNGmiLVu2KCSEazCAPzPGJFhrox2N8bsXAABcd+rUKfXu3TvP5bRZs2aKjY1Vnz59FB4e7uZ0CBQbNmzIVE4l6cMPP9TBgwedllNJmj17NuUUKOD4HQwAACRJ1lr97W9/06FDh3K1X7Vq1RQbG6vY2FjdeuutHkqHQOLssUa7du1yus8TTzyhli1beioSAC+hoAIAAEnSnDlztGLFCpfmhoWFqVevXurXr5/uvvtuBQWx7iLcJ+PnT11Rvnx5TZw40UNpAHgTBRUAAGjHjh0aPnx4tnOCg4PVsWNH9evXT127dlWJEiW8lA6B5OTJk06fferM5MmTVb58eQ8lAuBNFFQAAAJcUlKSHnzwQV25csXheJMmTRQbG6u+ffuyOio87v/+7/+cPkLGmWeeeUYTJ05UxYoVFR4enumre/fu+tOf/uShtADcjYIKAEAAs9YqLi5OP/74Y6btkZGRiomJUWxsrBo0aOCjdAhEub29V5LOnj2rs2fP6qeffsq0fejQoapZs6abkgHwBgoqAAAB7M0339Q777wjSSpZsqQeeOABxcbGql27dgoODvZxOgSivBRURyZOnKhnn32W5+4CBQwFFQCAAPX9999r6NChuueee9SvXz/16NFDJUuW9HUsBLBffvlF+/bty9cxgoODtWDBAvXv3989oQB4FQUVAIAAdejQIe3du1dVqlTxdRRAkvPHy7iqRIkSWr58ubp06eKmRAC8zaWCaozpJGm6pGBJC6y1k24YHynp4QzHrCcp3Fp70hiTKClJUqqkFGtttJuyAwCAfOjcubOvIwCZ5Of23vLly2v16tVq0aKFGxMB8LYcC6oxJljSLEn3SDoiaasx5iNr7ffX5lhrX5L0Uvr8+yUNt9aezHCYdtba392aHAAAAIWGtTbPV1Br1KihtWvXqm7dum5OBcDbXHmqdnNJ+621B6y1VyQtkdQtm/l9Jb3njnAAAAAIDPv379fhw4dzvV+jRo20adMmyilQSLhSUKtIyvinxZH0bVkYY0pI6iTp/2XYbCV9aoxJMMYMyGtQAAAAFF55ub23bdu2WrdunSIjIz2QCIAvuPIZVEdrczt7evL9kjbecHtva2vtUWNMRUmfGWP2WmvXZznJ1fI6QJKqV6/uQiwAAAAUFrm9vfevf/2r3n77bRUtWtRDiQD4gitXUI9IqpbhdVVJR53M7aMbbu+11h5N//W4pA909ZbhLKy186210dba6PDwcBdiAQAAoDBIS0vLVUEdMmSI3nvvPcopUAi5UlC3SqpjjKlljCmiqyX0oxsnGWNuktRG0ocZtpU0xoRd+15SR0m73REcAAAAhcOuXbv0xx9/uDR3woQJmjFjhoKDgz2cCoAv5HiLr7U2xRgzRNJaXX3MzEJr7XfGmIHp43PTp/aQ9Km19nyG3StJ+sAYc+1c71pr17jzBwAAAEDB5srnT4ODg7VgwQL179/f84EA+IxLz0G11n4s6eMbts294fWbkt68YdsBSY3ylRAAAACFWk639xYvXlzLly/Xvffe66VEAHzFpYIKAAAAeEJycrLWr8+yfuZ15cuX16pVq9SyZUsvpgLgKxRUAAAA+MyWLVt07tw5h2M1atTQ2rVrecYpEEBcWSQJAAAA8Ahnt/c2bNhQmzZtopwCAYaCCgAAAJ9xtEBSmzZttH79ekVGRvogEQBfoqACAADAJy5cuKD//ve/mbb16tVLa9asUZkyZXyUCoAvUVABAADgExs3btSVK1euvx48eLCWLFmiYsWK+TAVAF+ioAIAAMAnMt7eO378eM2cOVPBwcE+TATA11jFFwAAAD7xxRdfKDg4WK+99poeffRRX8cB4AcoqAAAAPC6U6dOae/evVq5cqXuu+8+X8cB4CcoqAAAAPC67777Tp999platmzp6ygA/AgFFQAAAF7XunVrGWN8HQOAn2GRJAAAAHgd5RSAIxRUAAAAAIBfoKACAAAAAPwCBRUAAAAA4BcoqAAAAAAAv0BBBQAAAAD4BQoqAAAAAMAvUFABAAAAAH6BggoAAAAA8AsUVAAAAACAX6CgAgAAAAD8AgUVAAAAAOAXKKgAAAAAAL9AQQUAAAAA+AUKKgAAAADAL1BQAQAAAAB+gYIKAAAAAPALLhVUY0wnY8w+Y8x+Y8woB+NtjTFnjDE70r9ecHVfAAAAAAAkKSSnCcaYYEmzJN0j6YikrcaYj6y1398wdYO19r487gsAAAAACHCuXEFtLmm/tfaAtfaKpCWSurl4/PzsCwAAAAAIIK4U1CqSDmd4fSR9241aGWN2GmM+Mcbclst9AQAAAAABLsdbfCUZB9vsDa+3SaphrT1njOkiaaWkOi7ue/UkxgyQNECSqlev7kIsAAAAAEBh4soV1COSqmV4XVXS0YwTrLVnrbXn0r//WFKoMaaCK/tmOMZ8a220tTY6PDw8Fz8CAAAAAKAwcKWgbpVUxxhTyxhTRFIfSR9lnGCMqWyMMenfN08/7h+u7AsAAAAAgOTCLb7W2hRjzBBJayUFS1porf3OGDMwfXyupF6S4owxKZIuSupjrbWSHO7roZ8FAAAAAFCAmas90r9ER0fb+Ph4X8cAAAAAALiZMSbBWhvtaMyVW3wBAAAAAPA4CioAAAAAwC9QUAEAAAAAfoGCCgAAAADwCxRUAAAAAIBfoKACAAAAAPwCBRUAAAAA4BcoqAAAAAAAv0BBBQAAAAD4BQoqAAAAAMAvUFABAAAAAH6BggoAAAAA8AsUVAAAAACAX6CgAgAAAAD8AgUVAAAAAOAXKKgAAAAAAL9AQQUAAAAA+AUKKgAAAADAL1BQAQAAAAB+gYIKAAAAAPALFFQAAAAAgF+goAIAAAAA/AIFFQAAAADgFyioAAAAAAC/QEEFAAAAAPgFCioAAAAAwC9QUAEAAAAAfoGCCgAAAADwCy4VVGNMJ2PMPmPMfmPMKAfjDxtjdqV/bTLGNMowlmiM+dYYs8MYE+/O8AAAAACAwiMkpwnGmGBJsyTdI+mIpK3GmI+std9nmHZQUhtr7SljTGdJ8yW1yDDezlr7uxtzAwAAAAAKGVeuoDaXtN9ae8Bae0XSEkndMk6w1m6y1p5Kf/mNpKrujQkAAAAAKOxcKahVJB3O8PpI+jZnHpf0SYbXVtKnxpgEY8yA3EcEAAAAAASCHG/xlWQcbLMOJxrTTlcL6p0ZNre21h41xlSU9JkxZq+1dr2DfQdIGiBJ1atXdyEWAAAAAKAwceUK6hFJ1TK8rirp6I2TjDG3S1ogqZu19o9r2621R9N/PS7pA129ZTgLa+18a220tTY6PDzc9Z8AAAAAAFAouFJQt0qqY4ypZYwpIqmPpI8yTjDGVJe0QlKstfaHDNtLGmPCrn0vqaOk3e4KDwAAAAAoPHK8xddam2KMGSJpraRgSQuttd8ZYwamj8+V9IKk8pJmG2MkKcVaGy2pkqQP0reFSHrXWrvGIz8JAAAAAKBAM9Y6/DipT0VHR9v4eB6ZCgAAAACFjTEmIf2CZhau3OILAAAAAIDHUVABAAAAAH6BggoAAAAA8AsUVAAAAACAX6CgAgAAAAD8AgUVAAAAAOAXKKgAAAAAAL9AQQUAAAAA+AUKKgAAAADAL1BQAQAAAAB+gYIKAAAAAPALFFQAAAAAgF+goAIAAAAA/EKIrwMAAK7atGmTnn/+eQUHByssLExhYWEqXbq0w+8djZUqVUpBQfy7IwAAKLiMtdbXGbKIjo628fHxvo4BAF63Z88e9e7dW99++22e9i9ZsmS2xTanknvt+7Jly8oY4+afDgAAQDLGJFhrox2NcQUVAPxIvXr1tHnzZo0YMUJz5szJ9f7nz5/X+fPn9euvv+Y5w8iRIzV58uQ87w8AAJBX3AsGAH6mePHimj17tpYvX66bbrrJq+ceO3asJk+ezNVTAADgExRUAPBTvXr10o4dO9SyZUuvnO+ll17SmDFjKKcAAMBnKKgA4Mdq1qyp9evX69lnn/XoeWbNmqW///3vHj0HAABATiioAODnQkNDNWnSJK1Zs0bh4eFuPXZQUJDeeOMNDRo0yK3HBQAAyAsKKgAUEH/5y1+0c+dOdejQwW3HLF68uBISErR582b546ruAAAgsFBQAaAAiYiI0Nq1azV+/HgFBwfn+3jnz5/Xq6++qpYtW6pOnToaO3asfvzxRzckBQAAyD2egwoABdTXX3+thx56SIcPH3b7sZs3b66HH35YvXv3VqVKldx+fAAAELiyew4qV1ABoIC68847tWPHDnXr1s3tx96yZYuefvppValSRZ07d9Y777yj8+fPu/08AAAAGVFQAaAAK1eunD744APNmDFDRYoUcfvxU1NTtWbNGsXExKhixYqKiYnRJ598opSUFLefCwAAgFt8AaCQ2L59u3r37u2Vz5BWrFhRvXv3VkxMjJo1a8azUwEAgMu4xRcAAkCTJk2UkJCg2NjYHOe2bt1at912W57Pdfz4cc2cOVMtWrTQLbfcohdffFH79+/P8/EAAAAkCioAFCphYWFatGiR3nzzTZUoUcLpvKioKH377bfasWOHRo4cqSpVquT5nPv379fYsWNVp04dtWzZUjNnztTx48fzfDwAABC4KKgArktKSlJiYqKvY8ANHnnkEW3btk233367w/FDhw7JGKNGjRppypQpOnTokL788ks99thjKl26dJ7Pu3nzZg0dOlSRkZHq0qWLlixZkudjAdckJSXxnF641YEDB3Tx4kVfxwDggEsF1RjTyRizzxiz3xgzysG4McbMSB/fZYyJcnVfAL63YMECdezYURUqVNDtt9+udevW+ToS3KBu3bravHmzBg8enGXs559/zvQ6ODhY7dq10+uvv67ffvtNy5cvV/fu3RUaGpqnc6empuqTTz7R66+/nqf9geTkZH388cd66KGHVKlSJbE2Bdzl448/Vv369VW+fHl17txZixYt8nUkABnkuEiSMSZY0g+S7pF0RNJWSX2ttd9nmNNF0lOSukhqIWm6tbaFK/s6wiJJgPckJSWpbNmySk1Nvb6tePHiev/999WlSxcfJoM7rVixQo8//rhOnz4tSSpbtqxOnjyZ434nT57U+++/r8WLF2vDhg25Pu8bb7yh/v3753o/FCxHjx7Vp59+mu//1tZaJSQk6O2339Z7772nEydOXB8bOnSopk+fns+kCHQrV65U7969deXKlevbSpYsqdOnTyskJMSHyYDAkt9FkppL2m+tPWCtvSJpiaQbH7rXTdIie9U3ksoYYyJc3BeAD23atClTOZWkixcv6rXXXvNRInhCz549tWPHDrVq1UqSdOrUKSUlJeW4X7ly5TRgwACtX79eBw8e1IQJE1S/fn2XzlmsWDH17NkzX7nh/9asWaNGjRrl6+MBiYmJGj9+vOrVq6dmzZppxowZmcqpJL333ntKTk7OZ1oEumnTpmUqp5J0/vx5bd261UeJANzIlYJaRdLhDK+PpG9zZY4r+0qSjDEDjDHxxpj4G/+nBMBzNm7c6HD7XXfd5eUk8LQaNWpo3bp1eu6552SM0aFDh3K1f82aNfXcc89p9+7d2r59u0aMGKHIyEin87t27Zqvz7PCvyUnJ2vUqFHq3Lmzfv/9d1WvXj1X+586dUrz58/XXXfdpVq1aun555/Xvn37nM4/ceKEPvvss/zGRoBr27atw+18tAXwH64UVEcPt7vxvmBnc1zZ9+pGa+dba6OttdHh4eEuxALgDv369VONGjWybKegFk6hoaGaMGGC1q5dqwsXLuTpGMYYNW7cWC+//LJ+/vlnff7553r00UcVFhaWaV5MTIw7IsMPHTp0SG3atNHkyZOvb3OloF6+fFkffPCBHnjgAVWuXFlPPvmkvv76a5fP+/bbb+cpL3BNu3btsmy79dZb1a9fPx+kAeCIKwX1iKRqGV5XlXTUxTmu7AvAh26++WZ9/fXXqlu3rooUKaJ77rlH06dPV5MmTXwdDR50zz33qHnz5vk+TnBwsDp06KCFCxfqt99+09KlS9W1a1dFREToL3/5ixuSwt98+OGHatKkif773/9m2u6soFprtXHjRg0cOFARERHq2bOnVqxYkeU2S1esXLlSZ8+ezVNuQJJatWqlyZMnq127dgoNDVXDhg21bt26bO8GAeBdriySFKKrCx11kPSLri509JC19rsMc+6VNET//yJJM6y1zV3Z1xEWSQK879SpUwoJCclyFQzIi8uXL6to0aK+jgE3unz5sp599lmnCxVduHBBxYsXv/76hx9+0OLFi7V48WIdPHgw3+dv06aNYmJi9NBDD2X7jF/AVefOnVNaWhofRQB8ILtFknJcrsxam2KMGSJpraRgSQuttd8ZYwamj8+V9LGultP9ki5IejS7fd3wMwFws7Jly/o6AgoRymnhsn//fvXu3Vvbtm1zOF6xYkUVL15cJ06c0JIlS7R48WJt2bIl3+etV6+eYmNj9dBDDzn8KAKQH6VKlfJ1BAAO5HgF1Re4ggoAgH9YsmSJBgwYkO2qzxUrVlSzZs20Zs2aLKuC51alSpXUt29fxcbGqkmTJjLG0XIWAICCLF9XUAEAQOC5ePGihg0bpvnz5+c49/jx41q9enWez1WiRAn16NFDMTEx+vOf/8zzKAEggPF/AAAAkMmePXv04IMPavfu3R47R1BQkDp06KDY2Fh1796dz78DACRRUAEAQAZvvfWWBg0alOfHEOWkcePGiomJUd++fVk5FQCQBQUVAADo3LlzGjRokEeeNVq1alU9/PDDiomJUYMGDdx+fABA4UFBBQAgwO3cuVMPPvigfvjhB7cdMywsTL169VJsbKzatGmjoCBXHr0OAAh0FFQAAAKUtVbz5s3TsGHDdPnyZbccs2PHjnrsscfUtWvXTM9FBQDAFRRUAAAC0JkzZ/TEE09o+fLlbj1uaGgo5RQAkGfcbwMAQIDZunWrmjRp4vZyKkmrV6/Wvffem+1zUwEAcIaCCgBAgLDWaurUqWrdurUOHjzosfN89dVX6tixo06dOuWxcwAACidjrfV1hiyMMSckHfJ1jgKigqTffR0ChQrvKbgT7ye4E+8nuBPvJ7gb7ynX1bDWhjsa8MuCCtcZY+KttdG+zoHCg/cU3In3E9yJ9xPcifcT3I33lHtwiy8AAAAAwC9QUAEAAAAAfoGCWvDN93UAFDq8p+BOvJ/gTryf4E68n+BuvKfcgM+gAgAAAAD8AldQAQAAAAB+gYJaCBhj/mqM+c4Yk2aMYeUw5Mn/194du8pRhmEUPw8xEkHExkK8gViIGARjEyLpQooYRdFKQStLhQiCaOk/IDZ2KhYGRdBCtAgRI2lERY0SuQaCjReFW4iojRJ9LHaLgCkkV/hmhvODgZ2tTjHsfu/MzmySY0kuJLmY5LnRPZq3JK8l2U5yfnSL5i/J3iRnkmyuv+9OjG7SfCXZk+SzJF+vj6cXRjdp/pLsSvJVkvdHt8ydA+oynAceBs6ODtE8JdkFvAzcC+wHHk2yf2yVZu514NjoCC3GJeCZtncAh4An/YzSDvwBHGl7F3AAOJbk0OAmzd8JYHN0xBI4oC5A2822F0Z3aNYOAhfbft/2T+At4MHBTZqxtmeBn0d3aBna/tT2y/Xr31gtAm8ZW6W56srv693d682HsuiqJdkA7gNeGd2yBA6okmC10Pvhsv0tXPxJmqAk+4C7gU/HlmjO1j/HPAdsA6fbejxpJ14CngX+Hh2yBA6oM5HkwyTnr7B5lUv/h1zhPc8mS5qUJNcD7wBPt/11dI/mq+1fbQ8AG8DBJHeObtI8Jbkf2G77xeiWpbhmdID+m7ZHRzdo0baAvZftbwA/DmqRpH9JspvVcHqy7buje7QMbX9J8jGre+Z9qJuuxmHggSTHgT3ADUneaPvY4K7Z8gqqJIDPgduS3JrkWuAR4L3BTZIEQJIArwKbbV8c3aN5S3JTkhvXr68DjgLfja3SXLV9vu1G232s1k8fOZzujAPqAiR5KMkWcA/wQZJTo5s0L20vAU8Bp1g9fOTttt+OrdKcJXkT+AS4PclWkidGN2nWDgOPA0eSnFtvx0dHabZuBs4k+YbVCdrTbf1rEGki0nqbmSRJkiRpPK+gSpIkSZImwQFVkiRJkjQJDqiSJEmSpElwQJUkSZIkTYIDqiRJkiRpEhxQJUmSJEmT4IAqSZIkSZoEB1RJkiRJ0iT8A9mkN80FsQbtAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x432 with 1 Axes>"
       ]