mapFolding 0.15.4__py3-none-any.whl → 0.16.0__py3-none-any.whl

mapFolding/algorithms/matrixMeanders.py

@@ -1,119 +1,72 @@
-# ruff: noqa: D100 D103
+"""Count meanders with matrix transfer algorithm.
+
+Notes
+-----
+- Odd/even of `groupAlpha` == the odd/even of `curveLocations`. Proof: `groupAlphaIsEven = curveLocations & 1 & 1 ^ 1`.
+- Odd/even of `groupZulu` == `curveLocations` second-least significant bit. So `groupZuluIsEven = bool(curveLocations & 2 ^ 2)`.
+"""
 from functools import cache
-from gc import collect as goByeBye, set_threshold
-from typing import Any, Literal
-import gc
+from gc import collect as goByeBye
+from hunterMakesPy import raiseIfNone
+from mapFolding import MatrixMeandersState
+from mapFolding.algorithms.getBucketsTotal import getBucketsTotal
+from pathlib import Path
+from warnings import warn
 import numpy
+import pandas
 
-# DEVELOPMENT INSTRUCTIONS FOR THIS MODULE
-#
-# Avoid early-return guard clauses, short-circuit returns, and multiple exit points. This codebase enforces a
-# single-return-per-function pattern with stable shapes/dtypes due to AST transforms. An empty input is a problem, so allow it to
-# fail early.
-#
-# If an algorithm has potential for infinite loops, fix the root cause: do NOT add artificial safety limits (e.g., maxIterations
-# counters) to prevent infinite loops.
-#
-# Always use semantic column, index, or slice identifiers: Never hardcode the locations.
-
-# TODO `set_threshold`: I know 0 means disabled, but I don't even understand if 1 means "as frequently as possible" or "almost never".
-set_threshold(1, 1, 1)
-Z0Z_bit_lengthSafetyLimit: int = 61
-
-type DataArray1D = numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64 | numpy.signedinteger[Any]]]
-type DataArray2columns = numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]
-type DataArray3columns = numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]
-type SelectorBoolean = numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]]
-type SelectorIndices = numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.intp]]
-
-# NOTE This code blocks enables semantic references to your data.
-columnsArrayCurveGroups = columnsArrayTotal = 3
-columnΩ: int = (columnsArrayTotal - columnsArrayTotal) - 1  # Something _feels_ right about this instead of `= -1`.
-columnDistinctCrossings = columnΩ = columnΩ + 1
-columnGroupAlpha = columnΩ = columnΩ + 1
-columnGroupZulu = columnΩ = columnΩ + 1
-if columnΩ != columnsArrayTotal - 1:
-	message = f"Please inspect the code above this `if` check. '{columnsArrayTotal = }', therefore '{columnΩ = }' must be '{columnsArrayTotal - 1 = }' due to 'zero-indexing.'"
-	raise ValueError(message)
-del columnsArrayTotal, columnΩ
-
-columnsArrayCurveLocations = columnsArrayTotal = 2
-columnΩ: int = (columnsArrayTotal - columnsArrayTotal) - 1
-columnDistinctCrossings = columnΩ = columnΩ + 1
-columnCurveLocations = columnΩ = columnΩ + 1
-if columnΩ != columnsArrayTotal - 1:
-	message = f"Please inspect the code above this `if` check. '{columnsArrayTotal = }', therefore '{columnΩ = }' must be '{columnsArrayTotal - 1 = }' due to 'zero-indexing.'"
-	raise ValueError(message)
-del columnsArrayTotal, columnΩ
-
-groupAlphaLocator: int = 0x55555555555555555555555555555555
-groupAlphaLocator64: int = 0x5555555555555555
-groupZuluLocator: int = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-groupZuluLocator64: int = 0xaaaaaaaaaaaaaaaa
-
-def convertDictionaryCurveLocations2CurveGroups(dictionaryCurveLocations: dict[int, int]) -> dict[tuple[int, int], int]:
-	return {(curveLocations & groupAlphaLocator, (curveLocations & groupZuluLocator) >> 1): distinctCrossings
-		for curveLocations, distinctCrossings in dictionaryCurveLocations.items()}
-
-def count(bridges: int, dictionaryCurveGroups: dict[tuple[int, int], int], bridgesMinimum: int = 0) -> tuple[int, dict[tuple[int, int], int]]:
-
-	dictionaryCurveLocations: dict[int, int] = {}
-	while bridges > bridgesMinimum:
-		bridges -= 1
-
-		curveLocationsMAXIMUM: int = 1 << (2 * bridges + 4)
+pathRoot: Path = Path.cwd() / 'curves'
+pathRoot.mkdir(exist_ok=True, parents=True)
 
-		for (groupAlpha, groupZulu), distinctCrossings in dictionaryCurveGroups.items():
-			groupAlphaCurves = groupAlpha != 1
-			groupZuluCurves = groupZulu != 1
+@cache
+def _flipTheExtra_0b1(intWithExtra_0b1: numpy.uint64) -> numpy.uint64:
+	return numpy.uint64(intWithExtra_0b1 ^ walkDyckPath(int(intWithExtra_0b1)))
 
-			# bridgesSimple
-			curveLocationAnalysis = ((groupAlpha | (groupZulu << 1)) << 2) | 3
-			if curveLocationAnalysis < curveLocationsMAXIMUM:
-				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+flipTheExtra_0b1AsUfunc = numpy.frompyfunc(_flipTheExtra_0b1, 1, 1)
 
-			if groupAlphaCurves:
-				curveLocationAnalysis = (groupAlpha >> 2) | (groupZulu << 3) | ((groupAlphaIsEven := 1 - (groupAlpha & 0b1)) << 1)
-				if curveLocationAnalysis < curveLocationsMAXIMUM:
-					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+def outfitDictionaryCurveGroups(state: MatrixMeandersState) -> dict[tuple[int, int], int]:
+	"""Outfit `dictionaryCurveGroups` so it may manage the computations for one iteration of the transfer matrix.
 
-			if groupZuluCurves:
-				curveLocationAnalysis = (groupZulu >> 1) | (groupAlpha << 2) | (groupZuluIsEven := 1 - (groupZulu & 1))
-				if curveLocationAnalysis < curveLocationsMAXIMUM:
-					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
-
-			# bridgesAligned
-			if groupZuluCurves and groupAlphaCurves:
-				# One Truth-check to select a code path
-				groupsCanBePairedTogether = (groupZuluIsEven << 1) | groupAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
-
-				if groupsCanBePairedTogether != 0:  # Case 0 (False, False)
-					XOrHere2makePair = 0b1
-					findUnpaired_0b1 = 0
-
-					if groupsCanBePairedTogether == 1:  # Case 1: (False, True)
-						while findUnpaired_0b1 >= 0:
-							XOrHere2makePair <<= 2
-							findUnpaired_0b1 += 1 if (groupAlpha & XOrHere2makePair) == 0 else -1
-						groupAlpha ^= XOrHere2makePair  # noqa: PLW2901
-					elif groupsCanBePairedTogether == 2:  # Case 2: (True, False)
-						while findUnpaired_0b1 >= 0:
-							XOrHere2makePair <<= 2
-							findUnpaired_0b1 += 1 if (groupZulu & XOrHere2makePair) == 0 else -1
-						groupZulu ^= XOrHere2makePair  # noqa: PLW2901
-
-					# Cases 1, 2, and 3 all compute curveLocationAnalysis
-					curveLocationAnalysis = ((groupZulu >> 2) << 1) | (groupAlpha >> 2)
-					if curveLocationAnalysis < curveLocationsMAXIMUM:
-						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
-
-		dictionaryCurveGroups = convertDictionaryCurveLocations2CurveGroups(dictionaryCurveLocations)
-		dictionaryCurveLocations = {}
-
-	return (bridges, dictionaryCurveGroups)
+	Parameters
+	----------
+	state : MatrixMeandersState
+		The current state of the computation, including `dictionaryCurveLocations`.
+
+	Returns
+	-------
+	dictionaryCurveGroups : dict[tuple[int, int], int]
+		A dictionary of `(groupAlpha, groupZulu)` to `distinctCrossings`.
+	"""
+	state.bitWidth = max(state.dictionaryCurveLocations.keys()).bit_length()
+	return {(curveLocations & state.locatorGroupAlpha, (curveLocations & state.locatorGroupZulu) >> 1): distinctCrossings
+		for curveLocations, distinctCrossings in state.dictionaryCurveLocations.items()}
 
 @cache
 def walkDyckPath(intWithExtra_0b1: int) -> int:
+	"""Find the bit position for flipping paired curve endpoints in meander transfer matrices.
+
+	Parameters
+	----------
+	intWithExtra_0b1 : int
+		Binary representation of curve locations with an extra bit encoding parity information.
+
+	Returns
+	-------
+	flipExtra_0b1_Here : int
+		Bit mask indicating the position where the balance condition fails, formatted as 2^(2k).
+
+	3L33T H@X0R
+	------------
+	Binary search for first negative balance in shifted bit pairs. Returns 2^(2k) mask for
+	bit position k where cumulative balance counter transitions from non-negative to negative.
+
+	Mathematics
+	-----------
+	Implements the Dyck path balance verification algorithm from Jensen's transfer matrix
+	enumeration. Computes the position where ∑(i=0 to k) (-1)^b_i < 0 for the first time,
+	where b_i are the bits of the input at positions 2i.
+
+	"""
 	findTheExtra_0b1: int = 0
 	flipExtra_0b1_Here: int = 1
 	while True:
@@ -126,223 +79,441 @@ def walkDyckPath(intWithExtra_0b1: int) -> int:
 			break
 	return flipExtra_0b1_Here
 
-@cache
-def _flipTheExtra_0b1(avoidingLookupsInPerRowLoop: int) -> numpy.uint64:
-	"""Be a docstring."""
-	return numpy.uint64(avoidingLookupsInPerRowLoop ^ walkDyckPath(avoidingLookupsInPerRowLoop))
-
-# TODO there is a better way to do this.
-flipTheExtra_0b1 = numpy.vectorize(_flipTheExtra_0b1, otypes=[numpy.uint64])
-"""The vectorize function is provided primarily for convenience, not for performance. The implementation is essentially a for loop."""
-
-def aggregateCurveLocations(arrayCurveLocations: DataArray2columns) -> DataArray3columns:
-	arrayCurveGroups: DataArray3columns = numpy.tile(
-		A=numpy.unique(arrayCurveLocations[:, columnCurveLocations])
-		, reps=(columnsArrayCurveGroups, 1)
-		).T
-	arrayCurveGroups[:, columnDistinctCrossings] = 0
-	numpy.add.at(
-		arrayCurveGroups[:, columnDistinctCrossings]
-		, numpy.searchsorted(
-			a=arrayCurveGroups[:, columnCurveLocations]
-			, v=arrayCurveLocations[:, columnCurveLocations])
-		, arrayCurveLocations[:, columnDistinctCrossings]
-	)
-	# I'm computing groupZulu from curveLocations that are physically in `arrayCurveGroups`, so I'm using `columnCurveLocations`.
-	numpy.bitwise_and(arrayCurveGroups[:, columnCurveLocations], numpy.uint64(groupZuluLocator64), out=arrayCurveGroups[:, columnGroupZulu])
-	numpy.right_shift(arrayCurveGroups[:, columnGroupZulu], 1, out=arrayCurveGroups[:, columnGroupZulu])
-	# NOTE Do not alphabetize these operations. This column has curveLocations data that groupZulu needs.
-	arrayCurveGroups[:, columnGroupAlpha] &= groupAlphaLocator64
-	return arrayCurveGroups
-
-def convertDictionaryCurveGroups2array(dictionaryCurveGroups: dict[tuple[int, int], int]) -> DataArray3columns:
-	arrayCurveGroups: DataArray3columns = numpy.tile(numpy.fromiter(dictionaryCurveGroups.values(), dtype=numpy.uint64), (columnsArrayCurveGroups, 1)).T
-	arrayKeys: DataArray2columns = numpy.array(list(dictionaryCurveGroups.keys()), dtype=numpy.uint64)
-	arrayCurveGroups[:, columnGroupAlpha] = arrayKeys[:, 0]
-	arrayCurveGroups[:, columnGroupZulu] = arrayKeys[:, 1]
-	return arrayCurveGroups
-
-def count64(bridges: int, arrayCurveGroups: DataArray3columns, bridgesMinimum: int = 0) -> tuple[int, DataArray3columns]:
-
-	while bridges > bridgesMinimum and int(arrayCurveGroups[:, columnDistinctCrossings].max()).bit_length() < Z0Z_bit_lengthSafetyLimit:
-		bridges -= 1
-		curveLocationsMAXIMUM: numpy.uint64 = numpy.uint64(1 << (2 * bridges + 4))
-
-		selectGroupAlphaCurves: SelectorBoolean = arrayCurveGroups[:, columnGroupAlpha] > numpy.uint64(1)
-		curveLocationsGroupAlpha: DataArray1D = ((arrayCurveGroups[selectGroupAlphaCurves, columnGroupAlpha] >> 2)
-			| (arrayCurveGroups[selectGroupAlphaCurves, columnGroupZulu] << 3)
-			| ((numpy.uint64(1) - (arrayCurveGroups[selectGroupAlphaCurves, columnGroupAlpha] & 1)) << 1)
-		)
-		selectGroupAlphaCurvesLessThanMaximum: SelectorIndices = numpy.flatnonzero(selectGroupAlphaCurves)[numpy.flatnonzero(curveLocationsGroupAlpha < curveLocationsMAXIMUM)]
+def areIntegersWide(state: MatrixMeandersState, dataframe: pandas.DataFrame | None = None, *, fixedSizeMAXIMUMcurveLocations: bool = False) -> bool:
+	"""Check if the largest values are wider than the maximum limits.
 
-		selectGroupZuluCurves: SelectorBoolean = arrayCurveGroups[:, columnGroupZulu] > numpy.uint64(1)
-		curveLocationsGroupZulu: DataArray1D = (arrayCurveGroups[selectGroupZuluCurves, columnGroupZulu] >> 1
-			| arrayCurveGroups[selectGroupZuluCurves, columnGroupAlpha] << 2
-			| (numpy.uint64(1) - (arrayCurveGroups[selectGroupZuluCurves, columnGroupZulu] & 1))
-		)
-		selectGroupZuluCurvesLessThanMaximum: SelectorIndices = numpy.flatnonzero(selectGroupZuluCurves)[numpy.flatnonzero(curveLocationsGroupZulu < curveLocationsMAXIMUM)]
+	Parameters
+	----------
+	state : MatrixMeandersState
+		The current state of the computation, including `dictionaryCurveLocations`.
+	dataframe : pandas.DataFrame | None = None
+		Optional DataFrame containing 'analyzed' and 'distinctCrossings' columns. If provided, use this instead of `state.dictionaryCurveLocations`.
+	fixedSizeMAXIMUMcurveLocations : bool = False
+		Set this to `True` if you cast `state.MAXIMUMcurveLocations` to the same fixed size integer type as `state.datatypeCurveLocations`.
 
-		selectBridgesSimpleLessThanMaximum: SelectorIndices = numpy.flatnonzero(
-			((arrayCurveGroups[:, columnGroupAlpha] << 2) | (arrayCurveGroups[:, columnGroupZulu] << 3) | 3) < curveLocationsMAXIMUM
-		) # Computation, but including `< curveLocationsMAXIMUM` is ~2% of total time.
+	Returns
+	-------
+	wider : bool
+		True if at least one integer is too wide.
+
+	Notes
+	-----
+	Casting `state.MAXIMUMcurveLocations` to a fixed-size 64-bit unsigned integer might cause the flow to be a little more
+	complicated because `MAXIMUMcurveLocations` is usually 1-bit larger than the `max(curveLocations)` value.
+
+	If you start the algorithm with very large `curveLocations` in your `dictionaryCurveLocations` (*i.e.,* A000682), then the
+	flow will go to a function that does not use fixed size integers. When the integers are below the limits (*e.g.,*
+	`bitWidthCurveLocationsMaximum`), the flow will go to a function with fixed size integers. In that case, casting
+	`MAXIMUMcurveLocations` to a fixed size merely delays the transition from one function to the other by one iteration.
+
+	If you start with small values in `dictionaryCurveLocations`, however, then the flow goes to the function with fixed size
+	integers and usually stays there until `distinctCrossings` is huge, which is near the end of the computation. If you cast
+	`MAXIMUMcurveLocations` into a 64-bit unsigned integer, however, then around `state.kOfMatrix == 28`, the bit width of
+	`MAXIMUMcurveLocations` might exceed the limit. That will cause the flow to go to the function that does not have fixed size
+	integers for a few iterations before returning to the function with fixed size integers.
+	"""
+	if dataframe is None:
+		curveLocationsWidest: int = max(state.dictionaryCurveLocations.keys()).bit_length()
+		distinctCrossingsWidest: int = max(state.dictionaryCurveLocations.values()).bit_length()
+	else:
+		curveLocationsWidest = int(dataframe['analyzed'].max()).bit_length()
+		distinctCrossingsWidest = int(dataframe['distinctCrossings'].max()).bit_length()
 
-		# Selectors for bridgesAligned -------------------------------------------------
-		selectGroupAlphaAtEven: SelectorBoolean = (arrayCurveGroups[:, columnGroupAlpha] & 1) == numpy.uint64(0)
-		selectGroupZuluAtEven: SelectorBoolean = (arrayCurveGroups[:, columnGroupZulu] & 1) == numpy.uint64(0)
-		selectBridgesAligned: SelectorBoolean = selectGroupAlphaCurves & selectGroupZuluCurves & (selectGroupAlphaAtEven | selectGroupZuluAtEven)
+	MAXIMUMcurveLocations: int = 0
+	if fixedSizeMAXIMUMcurveLocations:
+		MAXIMUMcurveLocations = state.MAXIMUMcurveLocations
 
-		SliceΩ: slice[int, int, Literal[1]] = slice(0,0)
-		sliceAllocateGroupAlpha = SliceΩ  = slice(SliceΩ.stop, SliceΩ.stop + selectGroupAlphaCurvesLessThanMaximum.size)
-		sliceAllocateGroupZulu = SliceΩ  = slice(SliceΩ.stop, SliceΩ.stop + selectGroupZuluCurvesLessThanMaximum.size)
-		sliceAllocateBridgesSimple = SliceΩ  = slice(SliceΩ.stop, SliceΩ.stop + selectBridgesSimpleLessThanMaximum.size)
-		sliceAllocateBridgesAligned = SliceΩ  = slice(SliceΩ.stop, SliceΩ.stop + selectBridgesAligned.size)
+	return (curveLocationsWidest > raiseIfNone(state.bitWidthCurveLocationsMaximum)
+		or distinctCrossingsWidest > raiseIfNone(state.bitWidthDistinctCrossingsMaximum)
+		or MAXIMUMcurveLocations > raiseIfNone(state.bitWidthCurveLocationsMaximum)
+		)
 
-		arrayCurveLocations: DataArray2columns = numpy.zeros((SliceΩ.stop, columnsArrayCurveLocations), dtype=arrayCurveGroups.dtype)
+def countBigInt(state: MatrixMeandersState) -> MatrixMeandersState:
+	"""Count meanders with matrix transfer algorithm using Python primitive `int` contained in a Python primitive `dict`.
 
-		arrayCurveLocations[sliceAllocateGroupAlpha, columnCurveLocations] = curveLocationsGroupAlpha[numpy.flatnonzero(curveLocationsGroupAlpha < curveLocationsMAXIMUM)]
-		arrayCurveLocations[sliceAllocateGroupAlpha, columnDistinctCrossings] = arrayCurveGroups[selectGroupAlphaCurvesLessThanMaximum, columnDistinctCrossings]
+	Parameters
+	----------
+	state : MatrixMeandersState
+		The algorithm state containing current `kOfMatrix`, `dictionaryCurveLocations`, and thresholds.
 
-		arrayCurveLocations[sliceAllocateGroupZulu, columnCurveLocations] = curveLocationsGroupZulu[numpy.flatnonzero(curveLocationsGroupZulu < curveLocationsMAXIMUM)]
-		arrayCurveLocations[sliceAllocateGroupZulu, columnDistinctCrossings] = arrayCurveGroups[selectGroupZuluCurvesLessThanMaximum, columnDistinctCrossings]
+	Notes
+	-----
+	The algorithm is sophisticated, but this implementation is straightforward. Compute each index one at a time, compute each
+	`curveLocations` one at a time, and compute each type of analysis one at a time.
+	"""
+	dictionaryCurveGroups: dict[tuple[int, int], int] = {}
 
-# TODO Uh, it sure looks like I am doing this computation twice. Computation (without assignment) ~ 1.5% of total time.
-		arrayCurveLocations[sliceAllocateBridgesSimple, columnCurveLocations] = (
-			(arrayCurveGroups[selectBridgesSimpleLessThanMaximum, columnGroupAlpha] << 2)
-			| (arrayCurveGroups[selectBridgesSimpleLessThanMaximum, columnGroupZulu] << 3)
-			| 3
-		)
-		arrayCurveLocations[sliceAllocateBridgesSimple, columnDistinctCrossings] = arrayCurveGroups[selectBridgesSimpleLessThanMaximum, columnDistinctCrossings]
+	while (state.kOfMatrix > 0 and areIntegersWide(state)):
+		state.kOfMatrix -= 1
 
-		curveLocationsGroupAlpha = None; del curveLocationsGroupAlpha  # pyright: ignore[reportAssignmentType] # noqa: E702
-		curveLocationsGroupZulu = None; del curveLocationsGroupZulu  # pyright: ignore[reportAssignmentType] # noqa: E702
-		selectBridgesSimpleLessThanMaximum = None; del selectBridgesSimpleLessThanMaximum # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupAlphaCurvesLessThanMaximum = None; del selectGroupAlphaCurvesLessThanMaximum # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupZuluCurvesLessThanMaximum = None; del selectGroupZuluCurvesLessThanMaximum # pyright: ignore[reportAssignmentType]  # noqa: E702
+		dictionaryCurveGroups = outfitDictionaryCurveGroups(state)
+		state.dictionaryCurveLocations.clear()
 		goByeBye()
 
-		# NOTE this MODIFIES `arrayCurveGroups` for bridgesPairedToOdd ---------------------------------------------------------------------------------------
-		selectBridgesGroupAlphaPairedToOdd: SelectorIndices = numpy.flatnonzero(selectBridgesAligned & selectGroupAlphaAtEven & (~selectGroupZuluAtEven))
-		arrayCurveGroups[selectBridgesGroupAlphaPairedToOdd, columnGroupAlpha] = flipTheExtra_0b1(
-			arrayCurveGroups[selectBridgesGroupAlphaPairedToOdd, columnGroupAlpha]
-		)
+		for (groupAlpha, groupZulu), distinctCrossings in dictionaryCurveGroups.items():
+			groupAlphaCurves: bool = groupAlpha > 1
+			groupZuluHasCurves: bool = groupZulu > 1
+			groupAlphaIsEven = groupZuluIsEven = 0
+
+			curveLocationAnalysis = ((groupAlpha | (groupZulu << 1)) << 2) | 3
+			# simple
+			if curveLocationAnalysis < state.MAXIMUMcurveLocations:
+				state.dictionaryCurveLocations[curveLocationAnalysis] = state.dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if groupAlphaCurves:
+				curveLocationAnalysis = (groupAlpha >> 2) | (groupZulu << 3) | ((groupAlphaIsEven := 1 - (groupAlpha & 1)) << 1)
+				if curveLocationAnalysis < state.MAXIMUMcurveLocations:
+					state.dictionaryCurveLocations[curveLocationAnalysis] = state.dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if groupZuluHasCurves:
+				curveLocationAnalysis = (groupZulu >> 1) | (groupAlpha << 2) | (groupZuluIsEven := 1 - (groupZulu & 1))
+				if curveLocationAnalysis < state.MAXIMUMcurveLocations:
+					state.dictionaryCurveLocations[curveLocationAnalysis] = state.dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if groupAlphaCurves and groupZuluHasCurves and (groupAlphaIsEven or groupZuluIsEven):
+				# aligned
+				if groupAlphaIsEven and not groupZuluIsEven:
+					groupAlpha ^= walkDyckPath(groupAlpha)  # noqa: PLW2901
+				elif groupZuluIsEven and not groupAlphaIsEven:
+					groupZulu ^= walkDyckPath(groupZulu)  # noqa: PLW2901
+
+				curveLocationAnalysis: int = ((groupZulu >> 2) << 1) | (groupAlpha >> 2)
+				if curveLocationAnalysis < state.MAXIMUMcurveLocations:
+					state.dictionaryCurveLocations[curveLocationAnalysis] = state.dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+	return state
+
+# ruff: noqa: B023
+
+def countPandas(state: MatrixMeandersState) -> MatrixMeandersState:
+	"""Count meanders with matrix transfer algorithm using pandas DataFrame.
+
+	Parameters
+	----------
+	state : MatrixMeandersState
+		The algorithm state containing current `kOfMatrix`, `dictionaryCurveLocations`, and thresholds.
+
+	Returns
+	-------
+	state : MatrixMeandersState
+		Updated state with new `kOfMatrix` and `dictionaryCurveLocations`.
+	"""
+	dataframeAnalyzed = pandas.DataFrame({
+		'analyzed': pandas.Series(name='analyzed', data=state.dictionaryCurveLocations.keys(), copy=False, dtype=state.datatypeCurveLocations)
+		, 'distinctCrossings': pandas.Series(name='distinctCrossings', data=state.dictionaryCurveLocations.values(), copy=False, dtype=state.datatypeDistinctCrossings)
+		}, dtype=state.datatypeCurveLocations
+	)
+	state.dictionaryCurveLocations.clear()
+
+	while (state.kOfMatrix > 0 and not areIntegersWide(state, dataframeAnalyzed)):
+
+		def aggregateCurveLocations()  -> None:
+			nonlocal dataframeAnalyzed
+			dataframeAnalyzed = dataframeAnalyzed.iloc[0:state.indexStartAnalyzed].groupby('analyzed', sort=False)['distinctCrossings'].aggregate('sum').reset_index()
+
+		def analyzeCurveLocationsAligned() -> None:
+			"""Compute `curveLocations` from `groupAlpha` and `groupZulu` if at least one is an even number.
+
+			Before computing `curveLocations`, some values of `groupAlpha` and `groupZulu` are modified.
+
+			Warning
+			-------
+			This function deletes rows from `dataframeCurveLocations`. Always run this analysis last.
+
+			Formula
+			-------
+			```python
+			if groupAlpha > 1 and groupZulu > 1 and (groupAlphaIsEven or groupZuluIsEven):
+				curveLocations = (groupAlpha >> 2) | ((groupZulu >> 2) << 1)
+			```
+			"""
+			nonlocal dataframeCurveLocations
+
+			# NOTE Step 1 drop unqualified rows
+
+			ImaGroupZulpha: pandas.Series = dataframeCurveLocations['curveLocations'].copy() # Ima `groupAlpha`.
+			ImaGroupZulpha &= state.locatorGroupAlpha # Ima `groupAlpha`.
+
+			dataframeCurveLocations = dataframeCurveLocations.loc[(ImaGroupZulpha > 1)] # if groupAlphaHasCurves
+
+			del ImaGroupZulpha
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= state.locatorGroupZulu # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+
+			dataframeCurveLocations = dataframeCurveLocations.loc[(ImaGroupZulpha > 1)] # if groupZuluHasCurves
 
-		selectBridgesGroupZuluPairedToOdd: SelectorIndices = numpy.flatnonzero(selectBridgesAligned & (~selectGroupAlphaAtEven) & selectGroupZuluAtEven)
-		arrayCurveGroups[selectBridgesGroupZuluPairedToOdd, columnGroupZulu] = flipTheExtra_0b1(
-			arrayCurveGroups[selectBridgesGroupZuluPairedToOdd, columnGroupZulu]
+			del ImaGroupZulpha
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= 0b10 # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+			ImaGroupZulpha &= 1 # (groupZulu & 1)
+			ImaGroupZulpha ^= 1 # (1 - (groupZulu ...))
+			dataframeCurveLocations.loc[:, 'analyzed'] = ImaGroupZulpha # selectorGroupZuluAtEven
+
+			del ImaGroupZulpha
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupAlpha`.
+			ImaGroupZulpha &= 1 # (groupAlpha & 1)
+			ImaGroupZulpha ^= 1 # (1 - (groupAlpha ...))
+			ImaGroupZulpha = ImaGroupZulpha.astype(bool) # selectorGroupAlphaAtODD
+
+			dataframeCurveLocations = dataframeCurveLocations.loc[(ImaGroupZulpha) | (dataframeCurveLocations.loc[:, 'analyzed'])] # if (groupAlphaIsEven or groupZuluIsEven)
+
+			del ImaGroupZulpha
+
+			# NOTE Step 2 modify rows
+
+			# Make a selector for groupZuluAtEven, so you can modify groupAlpha
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= 0b10 # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+			ImaGroupZulpha &= 1 # (groupZulu & 1)
+			ImaGroupZulpha ^= 1 # (1 - (groupZulu ...))
+			ImaGroupZulpha = ImaGroupZulpha.astype(bool) # selectorGroupZuluAtEven
+
+			dataframeCurveLocations.loc[:, 'analyzed'] = dataframeCurveLocations['curveLocations'] # Ima `groupAlpha`.
+			dataframeCurveLocations.loc[:, 'analyzed'] &= state.locatorGroupAlpha # (groupAlpha)
+
+			# if groupAlphaIsEven and not groupZuluIsEven, modifyGroupAlphaPairedToOdd
+			dataframeCurveLocations.loc[(~ImaGroupZulpha), 'analyzed'] = state.datatypeCurveLocations( # pyright: ignore[reportCallIssue, reportArgumentType]
+				flipTheExtra_0b1AsUfunc(dataframeCurveLocations.loc[(~ImaGroupZulpha), 'analyzed']))
+
+			del ImaGroupZulpha
+
+			# if groupZuluIsEven and not groupAlphaIsEven, modifyGroupZuluPairedToOdd
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= state.locatorGroupZulu # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+
+			ImaGroupZulpha.loc[(dataframeCurveLocations.loc[:, 'curveLocations'] & 1).astype(bool)] = state.datatypeCurveLocations( # pyright: ignore[reportArgumentType, reportCallIssue]
+				flipTheExtra_0b1AsUfunc(ImaGroupZulpha.loc[(dataframeCurveLocations.loc[:, 'curveLocations'] & 1).astype(bool)])) # pyright: ignore[reportCallIssue, reportUnknownArgumentType, reportArgumentType]
+
+			# NOTE Step 3 compute curveLocations
+
+			dataframeCurveLocations.loc[:, 'analyzed'] //= 2**2 # (groupAlpha >> 2)
+
+			ImaGroupZulpha //= 2**2 # (groupZulu >> 2)
+			ImaGroupZulpha *= 2**1 # ((groupZulu ...) << 1)
+
+			dataframeCurveLocations.loc[:, 'analyzed'] |= ImaGroupZulpha # ... | (groupZulu ...)
+
+			del ImaGroupZulpha
+
+			dataframeCurveLocations.loc[dataframeCurveLocations['analyzed'] >= state.MAXIMUMcurveLocations, 'analyzed'] = 0
+
+		def analyzeCurveLocationsAlpha() -> None:
+			"""Compute `curveLocations` from `groupAlpha`.
+
+			Formula
+			-------
+			```python
+			if groupAlpha > 1:
+				curveLocations = ((1 - (groupAlpha & 1)) << 1) | (groupZulu << 3) | (groupAlpha >> 2)
+			# `(1 - (groupAlpha & 1)` is an evenness test.
+			```
+			"""
+			nonlocal dataframeCurveLocations
+			dataframeCurveLocations['analyzed'] = dataframeCurveLocations['curveLocations']
+			dataframeCurveLocations.loc[:, 'analyzed'] &= 1 # (groupAlpha & 1)
+			dataframeCurveLocations.loc[:, 'analyzed'] ^= 1 # (1 - (groupAlpha ...))
+
+			dataframeCurveLocations.loc[:, 'analyzed'] *= 2**1 # ((groupAlpha ...) << 1)
+
+			ImaGroupZulpha: pandas.Series = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= state.locatorGroupZulu # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+
+			ImaGroupZulpha *= 2**3 # (groupZulu << 3)
+			dataframeCurveLocations.loc[:, 'analyzed'] |= ImaGroupZulpha # ... | (groupZulu ...)
+
+			del ImaGroupZulpha
+
+			dataframeCurveLocations.loc[:, 'analyzed'] *= 2**2 # ... | (groupAlpha >> 2)
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupAlpha`.
+			ImaGroupZulpha &= state.locatorGroupAlpha # Ima `groupAlpha`.
+
+			dataframeCurveLocations.loc[:, 'analyzed'] |= ImaGroupZulpha # ... | (groupAlpha)
+			dataframeCurveLocations.loc[:, 'analyzed'] //= 2**2 # (... >> 2)
+
+			dataframeCurveLocations.loc[(ImaGroupZulpha <= 1), 'analyzed'] = 0 # if groupAlpha > 1
+
+			del ImaGroupZulpha
+
+			dataframeCurveLocations.loc[dataframeCurveLocations['analyzed'] >= state.MAXIMUMcurveLocations, 'analyzed'] = 0
+
+		def analyzeCurveLocationsSimple() -> None:
+			"""Compute curveLocations with the 'simple' bridges formula.
+
+			Formula
+			-------
+			```python
+			curveLocations = ((groupAlpha | (groupZulu << 1)) << 2) | 3
+			```
+
+			Notes
+			-----
+			Using `+= 3` instead of `|= 3` is valid in this specific case. Left shift by two means the last bits are '0b00'. '0 + 3'
+			is '0b11', and '0b00 | 0b11' is also '0b11'.
+
+			"""
+			nonlocal dataframeCurveLocations
+			dataframeCurveLocations['analyzed'] = dataframeCurveLocations['curveLocations']
+			dataframeCurveLocations.loc[:, 'analyzed'] &= state.locatorGroupAlpha
+
+			groupZulu: pandas.Series = dataframeCurveLocations['curveLocations'].copy()
+			groupZulu &= state.locatorGroupZulu
+			groupZulu //= 2**1 # (groupZulu >> 1)
+			groupZulu *= 2**1 # (groupZulu << 1)
+
+			dataframeCurveLocations.loc[:, 'analyzed'] |= groupZulu # ((groupAlpha | (groupZulu ...))
+
+			del groupZulu
+
+			dataframeCurveLocations.loc[:, 'analyzed'] *= 2**2 # (... << 2)
+			dataframeCurveLocations.loc[:, 'analyzed'] += 3 # (...) | 3
+			dataframeCurveLocations.loc[dataframeCurveLocations['analyzed'] >= state.MAXIMUMcurveLocations, 'analyzed'] = 0
+
+		def analyzeCurveLocationsZulu() -> None:
+			"""Compute `curveLocations` from `groupZulu`.
+
+			Formula
+			-------
+			```python
+			if groupZulu > 1:
+				curveLocations = (1 - (groupZulu & 1)) | (groupAlpha << 2) | (groupZulu >> 1)
+			```
+			"""
+			nonlocal dataframeCurveLocations
+			dataframeCurveLocations.loc[:, 'analyzed'] = dataframeCurveLocations['curveLocations'] # Ima `groupZulu`.
+			dataframeCurveLocations.loc[:, 'analyzed'] &= 0b10 # Ima `groupZulu`.
+			dataframeCurveLocations.loc[:, 'analyzed'] //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+			dataframeCurveLocations.loc[:, 'analyzed'] &= 1 # (groupZulu & 1)
+			dataframeCurveLocations.loc[:, 'analyzed'] ^= 1 # (1 - (groupZulu ...))
+
+			ImaGroupZulpha: pandas.Series = dataframeCurveLocations['curveLocations'].copy() # Ima `groupAlpha`.
+			ImaGroupZulpha &= state.locatorGroupAlpha # Ima `groupAlpha`.
+
+			ImaGroupZulpha *= 2**2 # (groupAlpha << 2)
+			dataframeCurveLocations.loc[:, 'analyzed'] |= ImaGroupZulpha # ... | (groupAlpha ...)
+
+			del ImaGroupZulpha
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= state.locatorGroupZulu # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+
+			ImaGroupZulpha //= 2**1 # (groupZulu >> 1)
+
+			dataframeCurveLocations.loc[:, 'analyzed'] |= ImaGroupZulpha # ... | (groupZulu ...)
+
+			del ImaGroupZulpha
+
+			ImaGroupZulpha = dataframeCurveLocations['curveLocations'].copy() # Ima `groupZulu`.
+			ImaGroupZulpha &= state.locatorGroupZulu # Ima `groupZulu`.
+			ImaGroupZulpha //= 2**1 # Ima `groupZulu` (groupZulu >> 1)
+
+			dataframeCurveLocations.loc[ImaGroupZulpha <= 1, 'analyzed'] = 0 # if groupZulu > 1
+
+			del ImaGroupZulpha
+
+			dataframeCurveLocations.loc[dataframeCurveLocations['analyzed'] >= state.MAXIMUMcurveLocations, 'analyzed'] = 0
+
+		def recordCurveLocations() -> None:
+			nonlocal dataframeAnalyzed
+
+			indexStopAnalyzed: int = state.indexStartAnalyzed + int((dataframeCurveLocations['analyzed'] > 0).sum()) # pyright: ignore[reportUnknownArgumentType, reportUnknownMemberType]
+
+			if indexStopAnalyzed > state.indexStartAnalyzed:
+				if len(dataframeAnalyzed.index) < indexStopAnalyzed:
+					warn(f"Lengthened `dataframeAnalyzed` from {len(dataframeAnalyzed.index)} to {indexStopAnalyzed=}; n={state.n}, {state.kOfMatrix=}.", stacklevel=2)
+					dataframeAnalyzed = dataframeAnalyzed.reindex(index=pandas.RangeIndex(indexStopAnalyzed), fill_value=0)
+
+				dataframeAnalyzed.loc[state.indexStartAnalyzed:indexStopAnalyzed - 1, ['analyzed', 'distinctCrossings']] = (
+					dataframeCurveLocations.loc[(dataframeCurveLocations['analyzed'] > 0), ['analyzed', 'distinctCrossings']
+								].to_numpy(dtype=state.datatypeCurveLocations, copy=False)
+				)
+
+				state.indexStartAnalyzed = indexStopAnalyzed
+
+			del indexStopAnalyzed
+
+		dataframeCurveLocations = pandas.DataFrame({
+			'curveLocations': pandas.Series(name='curveLocations', data=dataframeAnalyzed['analyzed'], copy=False, dtype=state.datatypeCurveLocations)
+			, 'analyzed': pandas.Series(name='analyzed', data=0, dtype=state.datatypeCurveLocations)
+			, 'distinctCrossings': pandas.Series(name='distinctCrossings', data=dataframeAnalyzed['distinctCrossings'], copy=False, dtype=state.datatypeDistinctCrossings)
+			} # pyright: ignore[reportUnknownArgumentType]
 		)
 
-		selectBridgesGroupAlphaPairedToOdd = None; del selectBridgesGroupAlphaPairedToOdd # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectBridgesGroupZuluPairedToOdd = None; del selectBridgesGroupZuluPairedToOdd # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupAlphaAtEven = None; del selectGroupAlphaAtEven # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupAlphaCurves = None; del selectGroupAlphaCurves # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupZuluAtEven = None; del selectGroupZuluAtEven # pyright: ignore[reportAssignmentType]  # noqa: E702
-		selectGroupZuluCurves = None; del selectGroupZuluCurves # pyright: ignore[reportAssignmentType]  # noqa: E702
+		del dataframeAnalyzed
 		goByeBye()
 
-		# bridgesAligned; bridgesAlignedAtEven, bridgesGroupAlphaPairedToOdd, bridgesGroupZuluPairedToOdd ------------------------------------------------------------------
-		curveLocationsBridgesAligned: DataArray1D = (((arrayCurveGroups[selectBridgesAligned, columnGroupZulu] >> 2) << 1)
-			| (arrayCurveGroups[selectBridgesAligned, columnGroupAlpha] >> 2)
+		state.bitWidth = int(dataframeCurveLocations['curveLocations'].max()).bit_length()
+		length: int = getBucketsTotal(state)
+		dataframeAnalyzed = pandas.DataFrame({
+			'analyzed': pandas.Series(0, pandas.RangeIndex(length), dtype=state.datatypeCurveLocations, name='analyzed')
+			, 'distinctCrossings': pandas.Series(0, pandas.RangeIndex(length), dtype=state.datatypeDistinctCrossings, name='distinctCrossings')
+			}, index=pandas.RangeIndex(length), columns=['analyzed', 'distinctCrossings'], dtype=state.datatypeCurveLocations # pyright: ignore[reportUnknownArgumentType]
 		)
-		selectBridgesAlignedLessThanMaximum: SelectorIndices = numpy.flatnonzero(selectBridgesAligned)[numpy.flatnonzero(curveLocationsBridgesAligned < curveLocationsMAXIMUM)]
 
-		sliceAllocateBridgesAligned = SliceΩ  = slice(sliceAllocateBridgesAligned.start, sliceAllocateBridgesAligned.stop - selectBridgesAligned.size + selectBridgesAlignedLessThanMaximum.size)
-		arrayCurveLocations[sliceAllocateBridgesAligned, columnDistinctCrossings] = arrayCurveGroups[selectBridgesAlignedLessThanMaximum, columnDistinctCrossings]
-		arrayCurveLocations[sliceAllocateBridgesAligned, columnCurveLocations] = curveLocationsBridgesAligned[numpy.flatnonzero(curveLocationsBridgesAligned < curveLocationsMAXIMUM)]
+		state.kOfMatrix -= 1
 
-		arrayCurveGroups = None; del arrayCurveGroups # pyright: ignore[reportAssignmentType]  # noqa: E702
-		curveLocationsBridgesAligned = None; del curveLocationsBridgesAligned  # pyright: ignore[reportAssignmentType] # noqa: E702
-		del curveLocationsMAXIMUM
-		selectBridgesAligned = None; del selectBridgesAligned  # pyright: ignore[reportAssignmentType] # noqa: E702
-		selectBridgesAlignedLessThanMaximum = None; del selectBridgesAlignedLessThanMaximum # pyright: ignore[reportAssignmentType]  # noqa: E702
-		goByeBye()
+		state.indexStartAnalyzed = 0
+
+		analyzeCurveLocationsSimple()
+		recordCurveLocations()
 
-		arrayCurveLocations.resize((SliceΩ.stop, columnsArrayCurveLocations))
-		arrayCurveGroups = aggregateCurveLocations(arrayCurveLocations)
+		analyzeCurveLocationsAlpha()
+		recordCurveLocations()
 
-		arrayCurveLocations = None; del arrayCurveLocations # pyright: ignore[reportAssignmentType]  # noqa: E702
-		del sliceAllocateBridgesAligned
-		del sliceAllocateBridgesSimple
-		del sliceAllocateGroupAlpha
-		del sliceAllocateGroupZulu
-		del SliceΩ
+		analyzeCurveLocationsZulu()
+		recordCurveLocations()
+
+		analyzeCurveLocationsAligned()
+		recordCurveLocations()
+		del dataframeCurveLocations
 		goByeBye()
 
-	return (bridges, arrayCurveGroups)
+		aggregateCurveLocations()
+
+		if state.n >= 45:  # for data collection
+			print(state.n, state.kOfMatrix+1, state.indexStartAnalyzed, sep=',')  # noqa: T201
 
-def convertArrayCurveGroups2dictionaryCurveGroups(arrayCurveGroups: DataArray3columns) -> dict[tuple[int, int], int]:
-	return {(int(row[columnGroupAlpha]), int(row[columnGroupZulu])): int(row[columnDistinctCrossings]) for row in arrayCurveGroups}
+	state.dictionaryCurveLocations = dataframeAnalyzed.set_index('analyzed')['distinctCrossings'].to_dict()
+	return state
 
-def doTheNeedful(n: int, dictionaryCurveLocations: dict[int, int]) -> int:
+def doTheNeedful(state: MatrixMeandersState) -> int:
 	"""Compute a(n) meanders with the transfer matrix algorithm.
 
 	Parameters
 	----------
-	n : int
-		The index in the OEIS ID sequence.
-	dictionaryCurveLocations : dict[int, int]
-		A dictionary mapping curve locations to their counts.
+	state : MatrixMeandersState
+		The algorithm state containing current `kOfMatrix`, `dictionaryCurveLocations`, and thresholds.
 
 	Returns
 	-------
 	a(n) : int
 		The computed value of a(n).
 
-	Making sausage
-	--------------
-
-	As first computed by Iwan Jensen in 2000, A000682(41) = 6664356253639465480.
+	Notes
+	-----
 	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bibtex
-	See also https://oeis.org/A000682
-
-	I'm sure you instantly observed that A000682(41) = (6664356253639465480).bit_length() = 63 bits. And A005316(44) =
-	(18276178714484582264).bit_length() = 64 bits.
 
-	If you ask NumPy 2.3, "What is your relationship with integers with more than 64 bits?"
-	NumPy will say, "It's complicated."
-
-	Therefore, to take advantage of the computational excellence of NumPy when computing A000682(n) for n > 41, I must make some
-	adjustments at the total count approaches 64 bits.
+	See Also
+	--------
+	https://oeis.org/A000682
+	https://oeis.org/A005316
+	"""
+	while state.kOfMatrix > 0:
+		goByeBye()
 
-	The second complication is bit-packed integers. I use a loop that starts at `bridges = n` and decrements (`bridges -= 1`)
-	`until bridges = 0`. If `bridges > 29`, some of the bit-packed integers have more than 64 bits. "Hey NumPy, can I use
-	bit-packed integers with more than 64 bits?" NumPy: "It's complicated." Therefore, while `bridges` is decrementing, I don't
-	use NumPy until I believe the bit-packed integers will be less than 64 bits.
+		if areIntegersWide(state):
+			state = countBigInt(state)
+		else:
+			state = countPandas(state)
 
-	A third factor that works in my favor is that peak memory usage occurs when all types of integers are well under 64-bits wide.
+	return sum(state.dictionaryCurveLocations.values())
 
-	In total, to compute a(n) for "large" n, I use three-stages.
-	1. I use Python primitive `int` contained in a Python primitive `dict`.
-	2. When the bit width of the bit-packed integers connected to `bridges` is small enough to use `numpy.uint64`, I switch to NumPy for the heavy lifting.
-	3. When `distinctCrossings` subtotals might exceed 64 bits, I must switch back to Python primitives.
-	"""
-# NOTE '29' is based on two things. 1) `bridges = 29`, groupZuluLocator = 0xaaaaaaaaaaaaaaaa.bit_length() = 64. 2) If `bridges =
-# 30` or a larger number, `OverflowError: int too big to convert`. Conclusion: '29' isn't necessarily correct or the best value:
-# it merely fits within my limited ability to assess the correct value.
-# NOTE the above was written when I had the `bridges >= bridgesMinimum` bug. So, apply '-1' to everything.
-# NOTE This default value is necessary: it prevents `count64` from returning an incomplete dictionary when that is not necessary.
-# TODO `count64_bridgesMaximum` might be a VERY good idea as a second safeguard against overflowing distinctCrossingsTotal. But
-# I'm pretty sure I should use an actual check on maximum bit-width in arrayCurveGroups[:, columnDistinctCrossings] at the start
-# of each while loop. Tests on A000682 showed that the max bit-width of arrayCurveGroups[:, columnDistinctCrossings] always
-# increased by 1 or 2 bits on each iteration: never 0 and never 3. I did not test A005316. And I do not have a mathematical proof of the limit.
-
-	count64_bridgesMaximum = 28
-	bridgesMinimum = 0
-	distinctCrossings64bitLimitAsValueOf_n = 41
-	distinctCrossingsSubtotal64bitLimitAsValueOf_n_WAG = distinctCrossings64bitLimitAsValueOf_n - 3
-	distinctCrossings64bitLimitSafetyMargin = 4
-
-	dictionaryCurveGroups: dict[tuple[int, int], int] = convertDictionaryCurveLocations2CurveGroups(dictionaryCurveLocations)
-
-	if n >= count64_bridgesMaximum:
-		if n >= distinctCrossingsSubtotal64bitLimitAsValueOf_n_WAG:
-			bridgesMinimum = n - distinctCrossingsSubtotal64bitLimitAsValueOf_n_WAG + distinctCrossings64bitLimitSafetyMargin
-		n, dictionaryCurveGroups = count(n, dictionaryCurveGroups, count64_bridgesMaximum)
-		gc.collect()
-	n, arrayCurveGroups = count64(n, convertDictionaryCurveGroups2array(dictionaryCurveGroups), bridgesMinimum)
-	if n > 0:
-		gc.collect()
-		n, dictionaryCurveGroups = count(n, convertArrayCurveGroups2dictionaryCurveGroups(arrayCurveGroups), bridgesMinimum=0)
-		distinctCrossingsTotal = sum(dictionaryCurveGroups.values())
-	else:
-		distinctCrossingsTotal = int(arrayCurveGroups[0, columnDistinctCrossings])
-	return distinctCrossingsTotal