mapFolding 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,10 +1,14 @@
-from typing import Any, Tuple
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
-from mapFolding import indexMy, indexTrack
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import jit
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
 def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     while my[indexMy.leaf1ndex.value]:
         if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,21 +1,27 @@
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import prange
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
 def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     gapsWherePARALLEL = gapsWhere.copy()
     myPARALLEL = my.copy()
     trackPARALLEL = track.copy()
     taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
         while my[indexMy.leaf1ndex.value]:
             if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
                 if my[indexMy.leaf1ndex.value] > foldGroups[-1]:

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,10 +1,15 @@
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
+from mapFolding import indexMy
+from mapFolding import indexTrack
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
 def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     leafBelow = track[indexTrack.leafBelow.value]
     gapRangeStart = track[indexTrack.gapRangeStart.value]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,28 +1,18 @@
-from mapFolding import indexMy, indexTrack
-from numpy import dtype, integer, ndarray
-from typing import Any, Tuple
-import numba
-import numpy
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 from mapFolding.syntheticModules.numba_countInitialize import countInitialize
 from mapFolding.syntheticModules.numba_countParallel import countParallel
 from mapFolding.syntheticModules.numba_countSequential import countSequential
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=True, cache=True, error_model='python', fastmath=False, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=True, cache=True, error_model='python', fastmath=False, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
 def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], mapShape: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    """What in tarnation is this stupid module and function?
-
-    - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
-    - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
-    - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-    - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
-        - No `TypedDict`
-        - The plebs must clean up their own memory problems
-        - No oversized integers
-        - No global variables, only global constants
-        - It won't accept pleb nonlocal variables either
-        - Python "class": they are all inferior to the jit class
-        - No `**kwargs`
-        - and just a few dozen-jillion other things."""
     countInitialize(connectionGraph, gapsWhere, my, track)
     if my[indexMy.taskDivisions.value] > 0:
         countParallel(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theDao.py

@@ -1,10 +1,10 @@
 from mapFolding import indexMy, indexTrack
+from numba import prange
 from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
-import numba
-import numpy
 
 def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    # `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an index without `.value`.
     my[indexMy.gap1ndex.value] += 1
 
 def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
@@ -103,9 +103,11 @@ def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integ
     return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
 def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-                    , gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]]
-                    , my: ndarray[Tuple[int], dtype[integer[Any]]]
-                    , track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+                        , gapsWhere: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,        my: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,     track: ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+                    ) -> None:
+
     while activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
             findGapsInitializeVariables(my=my, track=track)
@@ -130,20 +132,27 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
             return
 
 def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-                    , foldGroups: ndarray[Tuple[int], dtype[integer[Any]]]
-                    , gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]]
-                    , my: ndarray[Tuple[int], dtype[integer[Any]]]
-                    , track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+                    ,  foldGroups: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,   gapsWhere: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,          my: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,       track: ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+                ) -> None:
+
     gapsWherePARALLEL = gapsWhere.copy()
     myPARALLEL = my.copy()
     trackPARALLEL = track.copy()
+
     taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
+
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+
+        my[indexMy.taskIndex.value] = indexSherpa
+
         while activeLeafGreaterThan0Condition(my=my):
             if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
                 if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
@@ -170,9 +179,16 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
                 placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
+                        , foldGroups: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,  gapsWhere: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,         my: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,      track: ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+                    ) -> None:
+
     groupsOfFolds: int = 0
-    doFindGaps = True
+    doFindGaps = True # Frankly, I can't figure out if `doFindGaps` is or is not faster. Furthermore, I have a strong feeling there is an even better way.
+
     while activeLeafGreaterThan0Condition(my=my):
         if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
                 and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
@@ -199,12 +215,13 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
 def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-                , foldGroups: ndarray[Tuple[int], dtype[integer[Any]]]
-                , gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]]
-                , mapShape: ndarray[Tuple[int], dtype[integer[Any]]]
-                , my: ndarray[Tuple[int], dtype[integer[Any]]]
-                , track: ndarray[Tuple[int, int], dtype[integer[Any]]]
-                ) -> None:
+                    , foldGroups: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,  gapsWhere: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,   mapShape: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,         my: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                    ,      track: ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+                    ) -> None:
+
     countInitialize(connectionGraph, gapsWhere, my, track)
 
     if my[indexMy.taskDivisions.value] > 0:

mapFolding/theSSOT.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from mapFolding.theSSOTnumba import *
-from numpy import integer
+from numpy import dtype, integer, ndarray
 from types import ModuleType
 from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
 import enum
@@ -73,14 +73,14 @@ def getDispatcherCallable() -> Callable[..., None]:
     from mapFolding.syntheticModules import numba_doTheNeedful
     return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
 
-# NOTE I want this _concept_ to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
+# NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
-    connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
-    foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    mapShape: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
-    track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]
+    connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
+    foldGroups:      ndarray[Tuple[int]          , dtype[integer[Any]]]
+    gapsWhere:       ndarray[Tuple[int]          , dtype[integer[Any]]]
+    mapShape:        ndarray[Tuple[int]          , dtype[integer[Any]]]
+    my:              ndarray[Tuple[int]          , dtype[integer[Any]]]
+    track:           ndarray[Tuple[int, int]     , dtype[integer[Any]]]
 
 @enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
 class EnumIndices(enum.IntEnum):

mapFolding/theSSOTnumba.py

@@ -1,3 +1,4 @@
+"""I have so much truth, I need two files to contain it all!"""
 """TODO learn how to use this efficiently and effectively to solve problems, be DRY, and have SSOT."""
 from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
 import numba

{mapFolding-0.3.10.dist-info → mapFolding-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.10
+Version: 0.3.11
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -26,6 +26,7 @@ Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
+Requires-Dist: autoflake; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -35,6 +36,7 @@ Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: types-setuptools; extra == "testing"
+Requires-Dist: updateCitation; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 

{mapFolding-0.3.10.dist-info → mapFolding-0.3.11.dist-info}/RECORD

@@ -2,9 +2,9 @@ mapFolding/__init__.py,sha256=-6hIljicU0Ql3yWpw8prpLGSQGUCHsNrSuf7zDNs_Ko,1169
 mapFolding/basecamp.py,sha256=DISWQIzAF7o7WPUn2QZxMu3Ruwc0zkVPgceeUTUcfqo,3988
 mapFolding/beDRY.py,sha256=Gsj7NEBztbPoKszPibhW6pO9xwjAIPgaW411A_Quwz8,18654
 mapFolding/oeis.py,sha256=2kFIAnBu0Bs4rHceXqs1RyyEBM6A_5fR5562B4ShxVg,12311
-mapFolding/theDao.py,sha256=0ySeHdmNXA1X3aKs7tdJ1cQes_rWf9Vp0tdC1zSXf6U,13669
-mapFolding/theSSOT.py,sha256=vtqhR1E6wwqVKtGKBY0UBAGRYu6x3gtPBloBzzuZi6M,9826
-mapFolding/theSSOTnumba.py,sha256=ex_NnkGd3GWUQVrtWxKzsNmiSm2e091uhVmiZn0aPew,5568
+mapFolding/theDao.py,sha256=7_2oRHzKL4PI6nzOHBGoNfkEiVL38Yg1ccEhPgQpu-w,14386
+mapFolding/theSSOT.py,sha256=oFBmNHq-gJVgGszjY1qk2IWSYGsZgTik7jZvHOfvQcw,9886
+mapFolding/theSSOTnumba.py,sha256=zewnChuGSF3fxfv9RiVdcjjiP7-CmbCAAgD3T7du1hQ,5632
 mapFolding/reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
 mapFolding/reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
 mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
@@ -14,16 +14,15 @@ mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v
 mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
 mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
 mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-mapFolding/someAssemblyRequired/__init__.py,sha256=O-r-Oy7HK8RtIhXjBo99BPn7kOY-zDo4r1X_B3CYscI,121
+mapFolding/someAssemblyRequired/__init__.py,sha256=3JnAKXfaYPtmxV_4AnZ6KpCosT_0GFV5Nw7K8sz4-Uo,34
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-mapFolding/someAssemblyRequired/makeJob.py,sha256=j62UMwwGV3CtF0j6ByyCxOuRNDCtv3MqVGUEtBSsAfk,2589
-mapFolding/someAssemblyRequired/synthesizeJobNumba.py,sha256=fwWjayhHyef9UxpjGDpLKoCvkvwtVMITKczlEedUXpE,19358
+mapFolding/someAssemblyRequired/makeJob.py,sha256=2RtRAHBMDAiOsJpnj1-J1Yso3beQu5hk8bUfgE367Zs,2592
 mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=TU8lgoMr77pctvvmlfbT-XstQk4j6Jo8JcIuvAiCuMU,1316
-mapFolding/someAssemblyRequired/synthesizeModulesNumba.py,sha256=hg6FOJbaJcsiWrqv6sTqkxaXYkR_TKPyLS8sJGqRQB0,26460
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=d_aptX7pbgLxiXJnr-t0W6znDXqX77r8clfKQOTZfBw,4210
-mapFolding/syntheticModules/numba_countParallel.py,sha256=W1157Xd8xwLXpRK82OMgL7AyFu0jh70_dHhrZ0mtYIs,5416
-mapFolding/syntheticModules/numba_countSequential.py,sha256=Se4FNea9XOEfTVRJkNNdJHpsKu0CcLJGKmqUHvMqmrU,3593
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=DyfNpKHWSUD6vqL3gcv80eLvKeibtUm8aa-Zu_weuqE,2521
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=KjAh32G3TE2_SD9hA2tJvB8l6NvdkZXbVqqobxshoj4,39568
+mapFolding/syntheticModules/numba_countInitialize.py,sha256=5AfZQkyYR5FB4YCe_S09dCGZpmVv0FDP95HXFjZjVgE,4274
+mapFolding/syntheticModules/numba_countParallel.py,sha256=Lyas0W7M74jJctVpuIi1p4o_HQOlduVT-dXmtsGPWb8,5517
+mapFolding/syntheticModules/numba_countSequential.py,sha256=kmVwhBafv26GIFt7mAA1fIcFn3LqNkvNfdXU0P8Yq0s,3675
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=xbKeYWACpbVMNitWPQeTr8l-YY6Y228Lu_JRDjsAPfE,1369
 tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
 tests/conftest.py,sha256=tGRYkHfwVKGoMklBSQiTD8cTu-QL1wUSZd-52Xlnm50,7676
 tests/conftest_tmpRegistry.py,sha256=0XpGe7s2aJcjdEAqKs10vceW0_JAaK-Rp1UoPaL-BIo,2450
@@ -32,9 +31,9 @@ tests/test_oeis.py,sha256=F89HJ27y54NXcR2wMeBS4ea6R7EaEqpF_GkcU-BrsK4,5694
 tests/test_other.py,sha256=UpS0_WUfWA3wONuZwip5AMmzNmmBwYD7reQDZ9ziL_o,12224
 tests/test_tasks.py,sha256=ap_tKjHUN95vjzKo3xzBAQ3kMbdMJ_XXbOv9YIBJ5pY,2826
 tests/test_types.py,sha256=HklNCGThFiqQ89AOMkE7YkcfAPiZE32DpD3GMDUPQVc,177
-mapFolding-0.3.10.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.3.10.dist-info/METADATA,sha256=GYvtSr3qWSvPYIrPAlZuQZmUIxIVt0vkPYIn-X7WOnc,7690
-mapFolding-0.3.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.10.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.10.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.3.10.dist-info/RECORD,,
+mapFolding-0.3.11.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.3.11.dist-info/METADATA,sha256=PyhvxPMeeQH30FYdX_MN-hYO4X2siMUarCi-11a4Kx4,7785
+mapFolding-0.3.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.11.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.11.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.3.11.dist-info/RECORD,,