From aad9a9fcc2deed87835f84de022f2559b77bd20e Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 6 Aug 2024 09:00:44 +0200 Subject: [PATCH 01/24] Hypercube space initial commit --- geometric_kernels/kernels/matern_kernel.py | 3 + geometric_kernels/lab_extras/extras.py | 39 + geometric_kernels/lab_extras/jax/extras.py | 24 + geometric_kernels/lab_extras/numpy/extras.py | 24 + .../lab_extras/tensorflow/extras.py | 24 + geometric_kernels/lab_extras/torch/extras.py | 24 + geometric_kernels/spaces/__init__.py | 1 + geometric_kernels/spaces/hypercube.py | 210 +++++ geometric_kernels/utils/special_functions.py | 60 ++ geometric_kernels/utils/utils.py | 17 + notebooks/Hypercube.ipynb | 822 ++++++++++++++++++ 11 files changed, 1248 insertions(+) create mode 100644 geometric_kernels/spaces/hypercube.py create mode 100644 geometric_kernels/utils/special_functions.py create mode 100644 notebooks/Hypercube.ipynb diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index dadf0013..2575cbe4 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -24,6 +24,7 @@ DiscreteSpectrumSpace, Graph, Hyperbolic, + Hypercube, Hypersphere, Mesh, NoncompactSymmetricSpace, @@ -199,6 +200,8 @@ def default_num(space: DiscreteSpectrumSpace) -> int: return min( MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) + elif isinstance(space, Hypercube): + return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: return MaternGeometricKernel._DEFAULT_NUM_LEVELS diff --git a/geometric_kernels/lab_extras/extras.py b/geometric_kernels/lab_extras/extras.py index 6ce8bf07..aa3556ef 100644 --- a/geometric_kernels/lab_extras/extras.py +++ b/geometric_kernels/lab_extras/extras.py @@ -308,3 +308,42 @@ def complex_conj(x: B.Numeric): :param x: Array of any backend. """ + + +@dispatch +@abstract() +def logical_xor(x1: B.Bool, x2: B.Bool): + """ + Return logical XOR of two arrays. + + :param x1: + Array of any backend. + :param x2: + Array of any backend. + """ + + +@dispatch +@abstract() +def hamming_distance(x1: B.Bool, x2: B.Bool): + """ + Hamming distance between two boolean arrays. + + :param x1: + Array of any backend, of shape [N, D]. + :param x2: + Array of any backend, of shape [M, D]. + + The shape of the returned array will be [N, M]. + """ + + +@dispatch +@abstract() +def dtype_bool(reference: B.RandomState): + """ + Return `bool` dtype of a backend based on the reference. + + :param reference: + A random state to infer the backend from. + """ diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index c112f76a..a014e383 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -221,3 +221,27 @@ def complex_conj(x: B.JAXNumeric): Return complex conjugate """ return jnp.conj(x) + + +@dispatch +def logical_xor(x1: B.JAXNumeric, x2: B.JAXNumeric): + """ + Return logical XOR of two arrays. + """ + return jnp.logical_xor(x1, x2) + + +@dispatch +def hamming_distance(x1: B.JAXNumeric, x2: B.JAXNumeric): + """ + Hamming distance between two boolean arrays. + """ + return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + + +@dispatch +def dtype_bool(reference: B.JAXRandomState): # type: ignore + """ + Return `bool` dtype of a backend based on the reference. + """ + return bool diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index dfeed280..73253306 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -216,3 +216,27 @@ def complex_conj(x: B.NPNumeric): Return complex conjugate """ return np.conjugate(x) + + +@dispatch +def logical_xor(x1: B.NPNumeric, x2: B.NPNumeric): + """ + Return logical XOR of two arrays. + """ + return np.logical_xor(x1, x2) + + +@dispatch +def hamming_distance(x1: B.NPNumeric, x2: B.NPNumeric): + """ + Hamming distance between two boolean arrays. + """ + return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + + +@dispatch +def dtype_bool(reference: B.NPRandomState): # type: ignore + """ + Return `bool` dtype of a backend based on the reference. + """ + return bool diff --git a/geometric_kernels/lab_extras/tensorflow/extras.py b/geometric_kernels/lab_extras/tensorflow/extras.py index c59ce149..d2d06687 100644 --- a/geometric_kernels/lab_extras/tensorflow/extras.py +++ b/geometric_kernels/lab_extras/tensorflow/extras.py @@ -227,3 +227,27 @@ def complex_conj(x: B.TFNumeric): Return complex conjugate """ return tf.math.conj(x) + + +@dispatch +def logical_xor(x1: B.TFNumeric, x2: B.TFNumeric): + """ + Return logical XOR of two arrays. + """ + return tf.math.logical_xor(x1, x2) + + +@dispatch +def hamming_distance(x1: B.TFNumeric, x2: B.TFNumeric): + """ + Hamming distance between two boolean arrays. + """ + return tf.count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) + + +@dispatch +def dtype_bool(reference: B.TFRandomState): # type: ignore + """ + Return `bool` dtype of a backend based on the reference. + """ + return tf.bool diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index cf303ece..3c1b23cd 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -234,3 +234,27 @@ def complex_conj(x: B.TorchNumeric): Return complex conjugate """ return torch.conj(x) + + +@dispatch +def logical_xor(x1: B.TorchNumeric, x2: B.TorchNumeric): + """ + Return logical XOR of two arrays. + """ + return torch.logical_xor(x1, x2) + + +@dispatch +def hamming_distance(x1: B.TorchNumeric, x2: B.TorchNumeric): + """ + Hamming distance between two boolean arrays. + """ + return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + + +@dispatch +def dtype_bool(reference: B.TorchRandomState): # type: ignore + """ + Return `bool` dtype of a backend based on the reference. + """ + return torch.bool diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index c3447798..1f820709 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -11,6 +11,7 @@ from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph from geometric_kernels.spaces.hyperbolic import Hyperbolic +from geometric_kernels.spaces.hypercube import Hypercube from geometric_kernels.spaces.hypersphere import Hypersphere from geometric_kernels.spaces.lie_groups import CompactMatrixLieGroup from geometric_kernels.spaces.mesh import Mesh diff --git a/geometric_kernels/spaces/hypercube.py b/geometric_kernels/spaces/hypercube.py new file mode 100644 index 00000000..b90a8b06 --- /dev/null +++ b/geometric_kernels/spaces/hypercube.py @@ -0,0 +1,210 @@ +""" +This module provides the :class:`Hypercube` space and the respective +:class:`~.eigenfunctions.Eigenfunctions` subclass :class:`WalshFunctions`. +""" + +from itertools import combinations +from math import comb + +import lab as B +import numpy as np +from beartype.typing import List, Optional + +from geometric_kernels.lab_extras import dtype_double, float_like, hamming_distance +from geometric_kernels.spaces.base import DiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import ( + Eigenfunctions, + EigenfunctionsWithAdditionTheorem, +) +from geometric_kernels.utils.special_functions import ( + kravchuk_normalized, + walsh_function, +) +from geometric_kernels.utils.utils import chain + + +class WalshFunctions(EigenfunctionsWithAdditionTheorem): + r""" + Eigenfunctions of graph Laplacian on the hypercube $C = \{0, 1\}^d$ are + Walsh functions $w_T: C \to \{-1, 1\}$ given by + + .. math:: w_T(x_1, .., x_d) = (-1)^{\sum_{i \in T} x_i}, + + enumerated by all possible subsets $T$ of the set $\{1, .., d\}$. + + .. note:: + Since the degree matrix is a constant multiple of the identity, all + types of the graph Laplacian coincide on the hypercube up to a constant. + + Levels are the whole eigenspaces, comprising all Walsh functions $w_T$ with + the same cardinality of $T$. The addition theorem for these is based on + dynamically precomputed basis functions equivalent to certain + discretizations of the Kravchuk polynomials. + + :param dim: + Dimension $d$ of the hypercube. + + :param num_levels: + Specifies the number of levels of the spherical harmonics. + + :todo: + Implement explicit weighted_outerproduct and weighted_outerproduct_diag + which compute the product of weights and binom(d, j) in log scale (for + numerical stability). + """ + + def __init__(self, dim: int, num_levels: int) -> None: + assert num_levels <= dim + 1, "The number of levels should be at most dim+1." + self.dim = dim + self._num_levels = num_levels + self._num_eigenfunctions: Optional[int] = None # To be computed when needed. + + def __call__(self, X: B.Bool, **kwargs) -> B.Float: + result = B.zeros(float_like(X), *X.shape[:-1], self.num_eigenfunctions) + cur_ind = 0 + for level in range(self.num_levels): + for cur_combination in combinations(range(self.dim), level): + # result[:, cur_ind] = (-1)**B.sum(take_along_axis(X, cur_combination, axis=-1), axis=-1) + result[:, cur_ind] = walsh_function(self.dim, list(cur_combination), X) + cur_ind += 1 + return result + + def _addition_theorem( + self, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs + ) -> B.Numeric: + + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + values = [ + comb(self.dim, level) + * kravchuk_normalized(self.dim, level, hamming_distances)[ + ..., None + ] # [N, N2, 1] + for level in range(self.num_levels) + ] + + return B.concat(*values, axis=-1) # [N, N2, L] + + def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: + """ + These are certain easy to compute constants. + """ + values = [ + comb(self.dim, level) * B.ones(float_like(X), *X.shape[:-1], 1) # [N, 1] + for level in range(self.num_levels) + ] + return B.concat(*values, axis=1) # [N, L] + + @property + def num_eigenfunctions(self) -> int: + if self._num_eigenfunctions is None: + J = 0 + for level in range(self.num_levels): + J += comb(self.dim, level) + self._num_eigenfunctions = J + return self._num_eigenfunctions + + @property + def num_levels(self) -> int: + return self._num_levels + + @property + def num_eigenfunctions_per_level(self) -> List[int]: + return [comb(self.dim, level) for level in range(self.num_levels)] + + +class Hypercube(DiscreteSpectrumSpace): + r""" + The GeometricKernels space representing the d-dimensional hypercube graph + $C = \{0, 1\}^d$, the combinatorial space of binary vectors of length $d$. + + The elements of this space are represented by d-dimensional boolean vectors. + + Levels are the whole eigenspaces. + + .. note:: + A tutorial on how to use this space is available in the + :doc:`Hypersphere.ipynb ` notebook. + + :param dim: + Dimension $d$ of the hypercube $C = \{0, 1\}^d$, a positive integer. + + .. admonition:: Citation + + If you use this GeometricKernels space in your research, please consider + citing :cite:t:`borovitskiy2023`. + """ + + def __init__(self, dim: int): + if dim < 1: + raise ValueError("dim must be a positive integer.") + self.dim = dim + + @property + def dimension(self) -> int: + """ + Returns d, the `dim` parameter that was passed down to `__init__`. + """ + return self.dim + + def get_eigenfunctions(self, num: int) -> Eigenfunctions: + """ + Returns the :class:`~.SphericalHarmonics` object with `num` levels. + + :param num: + Number of levels. + """ + return WalshFunctions(self.dim, num) + + def get_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues = np.array( + [ + 2 * level / self.dim # we assume normalized Laplacian + for level in range(num) + ] + ) + return B.reshape(eigenvalues, -1, 1) # [num, 1] + + def get_repeated_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues_per_level = self.get_eigenvalues(num) + + eigenfunctions = WalshFunctions(self.dim, num) + eigenvalues = chain( + B.squeeze(eigenvalues_per_level), + eigenfunctions.num_eigenfunctions_per_level, + ) # [J,] + return B.reshape(eigenvalues, -1, 1) # [J, 1] + + def random(self, key: B.RandomState, number: int) -> B.Numeric: + r""" + Sample uniformly random points on the hypercube $C = \{0, 1\}^d$. + + Always returns [N, D] boolean array of the `key`'s backend. + + :param key: + Either `np.random.RandomState`, `tf.random.Generator`, + `torch.Generator` or `jax.tensor` (representing random state). + :param number: + Number N of samples to draw. + + :return: + An array of `number` uniformly random samples on the space. + """ + key, random_points = B.random.rand( + key, dtype_double(key), number, self.dimension + ) + + random_points = random_points < 0.5 + + return key, random_points + + @property + def element_shape(self): + """ + :return: + [d]. + """ + return [self.dimension] diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py new file mode 100644 index 00000000..6779dac2 --- /dev/null +++ b/geometric_kernels/utils/special_functions.py @@ -0,0 +1,60 @@ +import lab as B +from beartype.typing import List + +from geometric_kernels.lab_extras import from_numpy, int_like, take_along_axis + + +def walsh_function(d: int, combination: List[int], x: B.Int) -> B.Float: + indices = B.cast(int_like(x), from_numpy(x, combination))[None, :] + + return (-1) ** B.sum(take_along_axis(x, indices, axis=-1), axis=-1) + + +def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: + r""" + This function returns $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the + Kravchuk polynomial defined below. + + Define the Kravchuk polynomial of degree d > 0 and order 0 <= j <= d as the + function $G_{d, j, m}$ of the independent variable 0 <= m <= d given by + + .. math:: G_{d, j, m} = \sum_{T \subseteq \{1, .., d\}, |T| = j} w_T(x). + + Here $w_T$ are the Walsh functions on the hypercube $C = \{0, 1\}^d$ and + $x \in C$ is an arbitrary binary vector with $m$ ones (the right-hand side + does not depend on the choice of such vector). + + .. note:: + We are using the three term recurrence relation to compute the Kravchuk + polynomials. Cf. Equation (60) in MacWilliams and Sloane "The Theory of + Error-Correcting Codes", 1977. The parameters q and \gamma from + MacWilliams and Sloane are set to be q = 2; \gamma = q - 1 = 1. + + .. note:: + We use the fact that $G_{d, j, 0} = binom{d}{j}$. + + :param d: + The degree of Kravhuk polynomial, an integer d > 0. + Maps to n in MacWilliams and Sloane. + :param j: d + The order of Kravhuk polynomial, an integer 0 <= j <= d. + Maps to k in MacWilliams and Sloane. + :param m: + The independent variable, an integer 0 <= m <= d. + Maps to x in MacWilliams and Sloane. + + :return: + $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial. + """ + assert d > 0 + assert 0 <= j and j <= d + assert B.all(0 <= m) and B.all(m <= d) + + if j == 0: + return 1 + 0 * m # 0*m is a hack to make the output have the same shape as m + elif j == 1: + return 1 - 2 * m / d + else: + rhs_1 = (d - 2 * m) * kravchuk_normalized(d, j - 1, m) + rhs_2 = -(j - 1) * kravchuk_normalized(d, j - 2, m) + return (rhs_1 + rhs_2) / (d - j + 1) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 0f55fe84..d16f7310 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -289,3 +289,20 @@ def get_resource_file_path(filename: str): else: with impresources.path(resources, filename) as path: yield path + + +def log_binomial(n: B.Int, k: B.Int) -> B.Float: + """ + Compute the logarithm of the binomial coefficient. + + :param n: + The number of elements in the set. + :param k: + The number of elements to choose. + + :return: + The logarithm of the binomial coefficient binom(n, k). + """ + assert B.all(0 <= k <= n) + + return B.loggamma(n + 1) - B.loggamma(k + 1) - B.loggamma(n - k + 1) diff --git a/notebooks/Hypercube.ipynb b/notebooks/Hypercube.ipynb new file mode 100644 index 00000000..73ad68a7 --- /dev/null +++ b/notebooks/Hypercube.ipynb @@ -0,0 +1,822 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on the Hypercube Graph\n", + "This notebook shows how define and evaluate kernels on the hypercube graph $C = \\{0, 1\\}^d$ for modeling data encoded as binary vectors with kernels that respect the geometry of the Hamming distance.\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the hypercube graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" + ] + } + ], + "source": [ + "# Import a backend, we use numpy in this example.\n", + "import numpy as np\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "# import geometric_kernels.jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces import Hypercube\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create a GeometricKernels `space` that corresponds to the 3-dimensional hypercube $C = \\{0, 1\\}^3$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [], + "source": [ + "hypercube = Hypercube(6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `hypercube` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(hypercube)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n", + "\n", + "**Note:** consider a graph with the scaled adjacency $\\mathbf{A}' = \\alpha^2 \\mathbf{A}$, for some $\\alpha > 0$.\n", + "Denote the kernel corresponding to $\\mathbf{A}$ by $k_{\\nu, \\kappa}$ and the kernel corresponding to $\\mathbf{A}'$ by $k_{\\nu, \\kappa}'$.\n", + "Then, as apparent from [the theory](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html), for the normalized graph Laplacian we have $k_{\\nu, \\kappa}' (i, j) = k_{\\nu, \\kappa} (i, j)$.\n", + "On the other hand, for the unnormalized graph Laplacian, we have $k_{\\nu, \\kappa}' (i, j) = k_{\\nu, \\alpha \\cdot \\kappa} (i, j)$, i.e. the lengthscale changes." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = np.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = np.array([3/2])\n", + "params_inf[\"nu\"] = np.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ True False True False False True]\n", + " [ True False False False True False]\n", + " [False False True False False True]] bool\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = hypercube.random(key, 3)\n", + "\n", + "print(xs, xs.dtype)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", + "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points`.\n", + "We define `base_point` and `other_points` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "base_point = np.array([0]*6)[None, :] # choosing a fixed node for kernel visualization\n", + "other_points = np.array([list(i) for i in itertools.product([0, 1], repeat=6)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, base_point,\n", + " other_points).flatten()\n", + "values_inf = kernel.K(params_inf, base_point,\n", + " other_points).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We prepare the networkx graph for visualizing the space" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "nx_graph = nx.hypercube_graph(6)\n", + "pos = {}\n", + "pos_list = [[3.18462, 1.34985], [3.46898, 2.21925], [3.0926, 0.433815], [2.21637, 1.30873], [2.28051, 0.928812], [2.86498, 2.26308], [2.29255, 1.64284], [2.64033, 2.62609], [2.26249, 0.620019], [1.22333, 1.6272], [1.30126, 1.27321], [1.8951, 2.67092], [3.07142, 3.07337], [2.8847, 1.2473], [1.83961, 2.30481], [1.90441, 1.92474], [2.24187, 3.47925], [1.91185, 1.59387], [0.847931, 2.64534], [0.921474, 2.26993], [2.64087, 1.90506], [2.23761, 0.0143973], [1.22294, 0.92365], [1.61988, 2.26091], [1.34731, 0.295391], [0.310627, 1.32606], [2.25335, 2.88409], [1.90784, 0.846041], [0.816332, 1.90238], [1.33814, 3.17037], [0.921199, 1.20639], [0., 2.22938], [2.55532, 2.28013], [2.16799, 0.321943], [1.5785, 2.6446], [1.24187, 0.594268], [2.14965, 3.18708], [1.85838, 1.23437], [1.28765, 3.48145], [0.835271, 1.58692], [1.57226, 1.90989], [1.27719, 0.], [0.5959, 2.24946], [0.418121, 0.397024], [1.22698, 2.87589], [0.848116, 0.849037], [0.413789, 3.08402], [0.00515571, 1.26256], [3.48101, 1.27272], [2.66405, 1.5921], [3.15933, 2.15967], [2.25775, 2.56393], [2.63577, 0.842368], [1.63869, 1.19036], [2.26401, 1.86592], [1.262, 2.18508], [2.56504, 1.22796], [1.58605, 1.5802], [2.17677, 2.23174], [1.20135, 2.56672], [1.59072, 0.82126], [0.611881, 1.2214], [1.19346, 1.85031], [0.295044, 2.14672]]\n", + "vert_list = [0, 32, 16, 8, 4, 2, 1, 33, 17, 9, 5, 3, 34, 18, 10, 6, 35, 19, 11, \\\n", + "7, 36, 20, 12, 37, 21, 13, 38, 22, 14, 39, 23, 15, 40, 24, 41, 25, \\\n", + "42, 26, 43, 27, 44, 28, 45, 29, 46, 30, 47, 31, 48, 49, 50, 51, 52, \\\n", + "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]\n", + "nodes = list(nx_graph.nodes)\n", + "for i in range(len(nx_graph.nodes)):\n", + " pos[nodes[vert_list[i]]] = pos_list[i]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64 64 64 (64,)\n" + ] + } + ], + "source": [ + "print(nx_graph.number_of_nodes(), 2**6, len(pos), values_32.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(0.0, values_32.min(), values_inf.min())\n", + "vmax = max(1.0, values_32.max(), values_inf.max())\n", + "\n", + "\n", + "# Red outline for the base_point:\n", + "edgecolors = [(0, 0, 0, 0)]*nx_graph.number_of_nodes()\n", + "# edgecolors[base_point] = (1, 0, 0, 1)\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.))\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=values_32,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_aspect(1)\n", + "ax1.set_title('Kernel: $k_{3/2, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values_inf,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_aspect(1)\n", + "ax2.set_title('Kernel: $k_{\\infty, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `Graph` space, the first element is `None` since the feature map is *deterministic*.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 6)):\n", + "[[ True False True False False True]\n", + " [ True False False False True False]\n", + " [False False True False False True]]\n", + "\n", + "emedding (shape = (3, 64)):\n", + "[[ 0.52479504 -0.22943667 0.22943667 -0.22943667 0.22943667 0.22943667\n", + " -0.22943667 -0.12546578 0.12546578 -0.12546578 -0.12546578 0.12546578\n", + " -0.12546578 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.12546578\n", + " 0.12546578 0.12546578 -0.12546578 -0.12546578 0.07799054 -0.07799054\n", + " -0.07799054 0.07799054 0.07799054 0.07799054 -0.07799054 -0.07799054\n", + " 0.07799054 0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", + " -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054 -0.07799054\n", + " 0.05268298 0.05268298 -0.05268298 -0.05268298 0.05268298 0.05268298\n", + " 0.05268298 -0.05268298 -0.05268298 0.05268298 -0.05268298 0.05268298\n", + " 0.05268298 -0.05268298 0.05268298 0.03772592 -0.03772592 -0.03772592\n", + " 0.03772592 -0.03772592 0.03772592 -0.02820844]\n", + " [ 0.52479504 -0.22943667 0.22943667 0.22943667 0.22943667 -0.22943667\n", + " 0.22943667 -0.12546578 -0.12546578 -0.12546578 0.12546578 -0.12546578\n", + " 0.12546578 0.12546578 -0.12546578 0.12546578 0.12546578 -0.12546578\n", + " 0.12546578 -0.12546578 0.12546578 -0.12546578 -0.07799054 -0.07799054\n", + " 0.07799054 -0.07799054 -0.07799054 0.07799054 -0.07799054 0.07799054\n", + " -0.07799054 0.07799054 0.07799054 -0.07799054 0.07799054 -0.07799054\n", + " 0.07799054 -0.07799054 -0.07799054 0.07799054 -0.07799054 -0.07799054\n", + " -0.05268298 0.05268298 -0.05268298 0.05268298 -0.05268298 0.05268298\n", + " 0.05268298 -0.05268298 0.05268298 0.05268298 -0.05268298 0.05268298\n", + " -0.05268298 -0.05268298 -0.05268298 0.03772592 -0.03772592 0.03772592\n", + " 0.03772592 0.03772592 -0.03772592 0.02820844]\n", + " [ 0.52479504 0.22943667 0.22943667 -0.22943667 0.22943667 0.22943667\n", + " -0.22943667 0.12546578 -0.12546578 0.12546578 0.12546578 -0.12546578\n", + " -0.12546578 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.12546578\n", + " 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.07799054 0.07799054\n", + " 0.07799054 -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", + " -0.07799054 -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", + " -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054 -0.07799054\n", + " -0.05268298 -0.05268298 0.05268298 0.05268298 -0.05268298 -0.05268298\n", + " -0.05268298 0.05268298 0.05268298 -0.05268298 -0.05268298 0.05268298\n", + " 0.05268298 -0.05268298 0.05268298 -0.03772592 0.03772592 0.03772592\n", + " -0.03772592 0.03772592 0.03772592 0.02820844]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.540871972436576e-15\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 3) (0, 1)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([], shape=(2, 0), dtype=int64)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from geometric_kernels.utils.special_functions import walsh_function\n", + "# walsh_function(3, np.asarray([], dtype=int), np.asarray([True, False, True], dtype=bool))\n", + "\n", + "print(np.array([[1,2,3], [4,5,6]]).shape, np.array([], dtype=int)[:, None].shape)\n", + "np.take_along_axis(np.array([[1,2,3], [4,5,6]]), np.array([], dtype=int)[None, :], axis=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-1.21817066 0.34257515]\n", + " [ 0.06262042 -1.43217014]\n", + " [-0.16312442 0.16001365]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = np.random.RandomState(seed=1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = np.random.RandomState(seed=1234)\n", + "key, samples = sample_paths(other_points, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=sample1,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=sample2,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using graphs and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{borovitskiy2023,\n", + " title={Isotropic Gaussian Processes on Finite Spaces of Graphs},\n", + " author={Borovitskiy, Viacheslav and Karimi, Mohammad Reza and Somnath, Vignesh Ram and Krause, Andreas},\n", + " booktitle={International Conference on Artificial Intelligence and Statistics},\n", + " year={2023},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{kondor2002,\n", + " title={Diffusion Kernels on Graphs and Other Discrete Structures},\n", + " author={Kondor, Risi Imre and Lafferty, John},\n", + " booktitle={International Conference on Machine Learning},\n", + " year={2002}\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "gkconda_updated_sh", + "language": "python", + "name": "gkconda_updated_sh" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From f61ff31bc844df1846fb9b6659fc87d034ca7f34 Mon Sep 17 00:00:00 2001 From: Alexander Terenin Date: Thu, 8 Aug 2024 03:13:43 -0400 Subject: [PATCH 02/24] Add citation file. (#140) Add citation file. --------- Signed-off-by: Alexander Terenin Co-authored-by: Viacheslav Borovitskiy --- CITATION.bib | 6 ++++++ CITATION.cff | 29 +++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) create mode 100644 CITATION.bib create mode 100644 CITATION.cff diff --git a/CITATION.bib b/CITATION.bib new file mode 100644 index 00000000..a729e293 --- /dev/null +++ b/CITATION.bib @@ -0,0 +1,6 @@ +@article{mostowsky2024, + title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs}, + author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy}, + year = {2024}, + journal = {arXiv:2407.08086}, +} \ No newline at end of file diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 00000000..16febcf9 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,29 @@ +cff-version: 1.2.0 +message: "If you use this software, please cite it as below." +title: "GeometricKernels" +authors: +- name: "GeometricKernels Contributors" +preferred-citation: + type: "article" + title: "The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs" + authors: + - family-names: "Mostowsky" + given-names: "Peter" + - family-names: "Dutordoir" + given-names: "Vincent" + - family-names: "Azangulov" + given-names: "Iskander" + - family-names: "Jaquier" + given-names: "Noémie" + - family-names: "Hutchinson" + given-names: "Michael John" + - family-names: "Ravuri" + given-names: "Aditya" + - family-names: "Rozo" + given-names: "Leonel" + - family-names: "Terenin" + given-names: "Alexander" + - family-names: "Borovitskiy" + given-names: "Viacheslav" + year: "2024" + journal: "arXiv:2407.08086" \ No newline at end of file From 349fa3c11e36aa0e631f336e731ae493017c1bd9 Mon Sep 17 00:00:00 2001 From: stoprightthere Date: Thu, 8 Aug 2024 12:42:28 +0300 Subject: [PATCH 03/24] Version 0.2.1 (#143) * Add sympy to the list of requirements sympy has always been required as a primary dependency. * Update version Update changelog. * Update CHANGELOG.md Signed-off-by: Viacheslav Borovitskiy --------- Signed-off-by: Viacheslav Borovitskiy Co-authored-by: Viacheslav Borovitskiy --- CHANGELOG.md | 8 ++++++++ pyproject.toml | 13 +++++++------ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 83599418..37534d37 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # CHANGELOG +## v0.2.1 - 08.08.2024 + Minor release with mostly cosmetic changes: + - fix documentation, + - update README.md, + - update the Bayesian Optimization notebook in `notebooks/other/`, + - add an explicit `sympy` requirement. + - add citation files to the repo. + ## v0.2 - 21.04.2024 New geometric kernel that *just works*, `kernels.MaternGeometricKernel`. Relies on *(hopefully)* sensible defaults we defined. Mostly by @stoprightthere. diff --git a/pyproject.toml b/pyproject.toml index b849291d..2e3e0f7b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,18 +23,19 @@ keywords=[ ] requires-python = ">=3.8" dependencies = [ + "backends>=1.5.4", + "einops", + "geomstats", "numpy>=1.16", - "scipy>=1.3", + "opt-einsum", "plum-dispatch>=2.2.0", - "backends>=1.5.4", "potpourri3d", "robust_laplacian", - "opt-einsum", - "geomstats", - "einops", + "scipy>=1.3", "spherical-harmonics-basis", + "sympy~=1.13", ] -version="0.2" +version="0.2.1" [project.urls] Documentation = "https://geometric-kernels.github.io/" From 5fd5f94c776dce786355b82d300a6dca8590c1d1 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Thu, 8 Aug 2024 20:03:30 +0200 Subject: [PATCH 04/24] Update CHANGELOG.md Signed-off-by: Viacheslav Borovitskiy --- CHANGELOG.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 37534d37..e8f969f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,11 +2,15 @@ ## v0.2.1 - 08.08.2024 Minor release with mostly cosmetic changes: - - fix documentation, - - update README.md, - - update the Bayesian Optimization notebook in `notebooks/other/`, - - add an explicit `sympy` requirement. - - add citation files to the repo. +* Add "If you have a question" section to README.md by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/131 +* Github cosmetics by @stoprightthere in https://github.com/geometric-kernels/GeometricKernels/pull/133 +* Replace all references to "gpflow" organization with "geometric-kernels" organization by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/134 +* Use fit_gpytorch_model or fit.fit_gpytorch_mll depening on the botorсh version by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/137 +* Add a missing type cast and fix a typo in kernels/karhunen_loeve.py by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/136 +* Minor documentation improvements by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/135 +* Add citation to the preprint of the GeometricKernels paper by @vabor112 in https://github.com/geometric-kernels/GeometricKernels/pull/138 +* Add citation file by @aterenin in https://github.com/geometric-kernels/GeometricKernels/pull/140 +* Fix dependencies (Version 0.2.1) by @stoprightthere in https://github.com/geometric-kernels/GeometricKernels/pull/143 ## v0.2 - 21.04.2024 New geometric kernel that *just works*, `kernels.MaternGeometricKernel`. Relies on *(hopefully)* sensible defaults we defined. Mostly by @stoprightthere. From e6b622941090015acb96569c00e4dd8fb96c3e73 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Fri, 9 Aug 2024 20:31:54 +0200 Subject: [PATCH 05/24] Tests, fixes and improvements for the Hypercube space --- geometric_kernels/lab_extras/extras.py | 12 +- geometric_kernels/lab_extras/jax/extras.py | 6 +- geometric_kernels/lab_extras/numpy/extras.py | 6 +- .../lab_extras/tensorflow/extras.py | 6 +- geometric_kernels/lab_extras/torch/extras.py | 6 +- geometric_kernels/spaces/eigenfunctions.py | 7 +- geometric_kernels/spaces/hypercube.py | 36 ++-- geometric_kernels/utils/special_functions.py | 84 ++++++++- geometric_kernels/utils/utils.py | 116 ++++++++++++- test_requirements.txt | 3 + tests/spaces/test_hypercube.py | 160 ++++++++++++++++++ tests/utils/test_special_functions.py | 142 ++++++++++++++++ tests/utils/test_utils.py | 113 +++++++++++++ 13 files changed, 651 insertions(+), 46 deletions(-) create mode 100644 tests/spaces/test_hypercube.py create mode 100644 tests/utils/test_special_functions.py create mode 100644 tests/utils/test_utils.py diff --git a/geometric_kernels/lab_extras/extras.py b/geometric_kernels/lab_extras/extras.py index aa3556ef..f1076d01 100644 --- a/geometric_kernels/lab_extras/extras.py +++ b/geometric_kernels/lab_extras/extras.py @@ -325,16 +325,12 @@ def logical_xor(x1: B.Bool, x2: B.Bool): @dispatch @abstract() -def hamming_distance(x1: B.Bool, x2: B.Bool): +def count_nonzero(x: B.Numeric, axis=None): """ - Hamming distance between two boolean arrays. + Count non-zero elements in an array. - :param x1: - Array of any backend, of shape [N, D]. - :param x2: - Array of any backend, of shape [M, D]. - - The shape of the returned array will be [N, M]. + :param x: + Array of any backend and of any shape. """ diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index a014e383..81c93846 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -232,11 +232,11 @@ def logical_xor(x1: B.JAXNumeric, x2: B.JAXNumeric): @dispatch -def hamming_distance(x1: B.JAXNumeric, x2: B.JAXNumeric): +def count_nonzero(x: B.JAXNumeric, axis=None): """ - Hamming distance between two boolean arrays. + Count non-zero elements in an array. """ - return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + return jnp.count_nonzero(x, axis=axis) @dispatch diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 73253306..1d9fe038 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -227,11 +227,11 @@ def logical_xor(x1: B.NPNumeric, x2: B.NPNumeric): @dispatch -def hamming_distance(x1: B.NPNumeric, x2: B.NPNumeric): +def count_nonzero(x: B.NPNumeric, axis=None): """ - Hamming distance between two boolean arrays. + Count non-zero elements in an array. """ - return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + return np.count_nonzero(x, axis=axis) @dispatch diff --git a/geometric_kernels/lab_extras/tensorflow/extras.py b/geometric_kernels/lab_extras/tensorflow/extras.py index d2d06687..8e613f15 100644 --- a/geometric_kernels/lab_extras/tensorflow/extras.py +++ b/geometric_kernels/lab_extras/tensorflow/extras.py @@ -238,11 +238,11 @@ def logical_xor(x1: B.TFNumeric, x2: B.TFNumeric): @dispatch -def hamming_distance(x1: B.TFNumeric, x2: B.TFNumeric): +def count_nonzero(x: B.TFNumeric, axis=None): """ - Hamming distance between two boolean arrays. + Count non-zero elements in an array. """ - return tf.count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) + return tf.math.count_nonzero(x, axis=axis) @dispatch diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index 3c1b23cd..15860ec5 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -245,11 +245,11 @@ def logical_xor(x1: B.TorchNumeric, x2: B.TorchNumeric): @dispatch -def hamming_distance(x1: B.TorchNumeric, x2: B.TorchNumeric): +def count_nonzero(x: B.TorchNumeric, axis=None): """ - Hamming distance between two boolean arrays. + Count non-zero elements in an array. """ - return logical_xor(x1[:, None, :], x2[None, :, :]).sum(axis=-1) + return torch.count_nonzero(x, dim=axis) @dispatch diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 91439972..8bdb9055 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -22,7 +22,6 @@ import lab as B from beartype.typing import List, Optional -from opt_einsum import contract as einsum from geometric_kernels.lab_extras import complex_like, is_complex, take_along_axis @@ -106,7 +105,7 @@ def weighted_outerproduct( else: sum_phi_phi_for_level = B.cast(B.dtype(weights), sum_phi_phi_for_level) - return einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) # [N, N2] + return B.einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) # [N, N2] def weighted_outerproduct_diag( self, weights: B.Numeric, X: B.Numeric, **kwargs @@ -132,7 +131,7 @@ def weighted_outerproduct_diag( else: phi_product_diag = B.cast(B.dtype(weights), phi_product_diag) - return einsum("id,ni->n", weights, phi_product_diag) # [N,] + return B.einsum("id,ni->n", weights, phi_product_diag) # [N,] @abc.abstractmethod def phi_product( @@ -301,7 +300,7 @@ def phi_product( X2 = X Phi_X = self.__call__(X, **kwargs) # [N, J] Phi_X2 = self.__call__(X2, **kwargs) # [N2, J] - return einsum("nl,ml->nml", Phi_X, Phi_X2) # [N, N2, J] + return B.einsum("nl,ml->nml", Phi_X, Phi_X2) # [N, N2, J] def phi_product_diag(self, X: B.Numeric, **kwargs): Phi_X = self.__call__(X, **kwargs) # [N, J] diff --git a/geometric_kernels/spaces/hypercube.py b/geometric_kernels/spaces/hypercube.py index b90a8b06..0b7ab007 100644 --- a/geometric_kernels/spaces/hypercube.py +++ b/geometric_kernels/spaces/hypercube.py @@ -10,7 +10,7 @@ import numpy as np from beartype.typing import List, Optional -from geometric_kernels.lab_extras import dtype_double, float_like, hamming_distance +from geometric_kernels.lab_extras import dtype_double, float_like from geometric_kernels.spaces.base import DiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, @@ -20,7 +20,7 @@ kravchuk_normalized, walsh_function, ) -from geometric_kernels.utils.utils import chain +from geometric_kernels.utils.utils import chain, hamming_distance class WalshFunctions(EigenfunctionsWithAdditionTheorem): @@ -60,14 +60,14 @@ def __init__(self, dim: int, num_levels: int) -> None: self._num_eigenfunctions: Optional[int] = None # To be computed when needed. def __call__(self, X: B.Bool, **kwargs) -> B.Float: - result = B.zeros(float_like(X), *X.shape[:-1], self.num_eigenfunctions) - cur_ind = 0 - for level in range(self.num_levels): - for cur_combination in combinations(range(self.dim), level): - # result[:, cur_ind] = (-1)**B.sum(take_along_axis(X, cur_combination, axis=-1), axis=-1) - result[:, cur_ind] = walsh_function(self.dim, list(cur_combination), X) - cur_ind += 1 - return result + return B.stack( + *[ + walsh_function(self.dim, list(cur_combination), X) + for level in range(self.num_levels) + for cur_combination in combinations(range(self.dim), level) + ], + axis=1, + ) def _addition_theorem( self, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs @@ -101,10 +101,7 @@ def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: @property def num_eigenfunctions(self) -> int: if self._num_eigenfunctions is None: - J = 0 - for level in range(self.num_levels): - J += comb(self.dim, level) - self._num_eigenfunctions = J + self._num_eigenfunctions = sum(self.num_eigenfunctions_per_level) return self._num_eigenfunctions @property @@ -147,6 +144,13 @@ def __init__(self, dim: int): def dimension(self) -> int: """ Returns d, the `dim` parameter that was passed down to `__init__`. + + .. note: + Although this is a graph, and graphs are generally treated as + 0-dimensional throughout GeometricKernels, we make an exception for + the hypercube. This is because it helps maintain good behavior of + Matérn kernels with the usual values of the smoothness parameter + nu, i.e. nu = 1/2, nu=3/2, nu=5/2. """ return self.dim @@ -162,7 +166,9 @@ def get_eigenfunctions(self, num: int) -> Eigenfunctions: def get_eigenvalues(self, num: int) -> B.Numeric: eigenvalues = np.array( [ - 2 * level / self.dim # we assume normalized Laplacian + 2 + * level + / self.dim # we assume normalized Laplacian (for numerical stability) for level in range(num) ] ) diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 6779dac2..b1a0e07b 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -1,13 +1,46 @@ +from math import sqrt + import lab as B -from beartype.typing import List +from beartype.typing import List, Optional + +from geometric_kernels.lab_extras import ( + count_nonzero, + float_like, + from_numpy, + int_like, + take_along_axis, +) +from geometric_kernels.utils.utils import hamming_distance + + +def walsh_function(d: int, combination: List[int], x: B.Bool) -> B.Float: + r""" + This function returns the value of the Walsh function + + .. math:: w_T(x_0, .., x_{d-1}) = (-1)^{\sum_{j \in T} x_j} -from geometric_kernels.lab_extras import from_numpy, int_like, take_along_axis + where $d$ is `d`, $T$ is `combination`, and $x = (x_0, .., x_{d-1})$ is `x`. + :param d: + The degree of the Walsh function and the dimension of its inputs. + An integer d > 0. + :param combination: + A subset of the set $\{0, .., d-1\}$ determining the particular Walsh + function. A list of integers. + :param x: + The batch of binary vectors $x = (x_0, .., x_{d-1})$ of shape [N, d]. + + :return: + The value of the Walsh function $w_T(x)$ evaluated for every $x$ in the + batch. An array of shape [N]. + + """ + assert x.ndim == 2 + assert x.shape[-1] == d -def walsh_function(d: int, combination: List[int], x: B.Int) -> B.Float: indices = B.cast(int_like(x), from_numpy(x, combination))[None, :] - return (-1) ** B.sum(take_along_axis(x, indices, axis=-1), axis=-1) + return (-1) ** count_nonzero(take_along_axis(x, indices, axis=-1), axis=-1) def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: @@ -18,7 +51,7 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: Define the Kravchuk polynomial of degree d > 0 and order 0 <= j <= d as the function $G_{d, j, m}$ of the independent variable 0 <= m <= d given by - .. math:: G_{d, j, m} = \sum_{T \subseteq \{1, .., d\}, |T| = j} w_T(x). + .. math:: G_{d, j, m} = \sum_{T \subseteq \{0, .., d-1\}, |T| = j} w_T(x). Here $w_T$ are the Walsh functions on the hypercube $C = \{0, 1\}^d$ and $x \in C$ is an arbitrary binary vector with $m$ ones (the right-hand side @@ -50,6 +83,8 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: assert 0 <= j and j <= d assert B.all(0 <= m) and B.all(m <= d) + m = B.cast(B.dtype_float(m), m) + if j == 0: return 1 + 0 * m # 0*m is a hack to make the output have the same shape as m elif j == 1: @@ -58,3 +93,42 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: rhs_1 = (d - 2 * m) * kravchuk_normalized(d, j - 1, m) rhs_2 = -(j - 1) * kravchuk_normalized(d, j - 2, m) return (rhs_1 + rhs_2) / (d - j + 1) + + +def hypercube_heat_kernel( + lengthscale: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, + normalized_laplacian: bool = True, +): + """ + Analytic formula for the heat kernel on the hypercube, see Equation (14) in + :cite:t:`borovitskiy2023`. + + :param lengthscale: + The length scale of the kernel, an array of shape [1]. + :param X: + A batch of inputs, an array of shape [N, d]. + :param X2: + A batch of inputs, an array of shape [N2, d]. + + :return: + The kernel matrix, an array of shape [N, N2]. + """ + if X2 is None: + X2 = X + + assert lengthscale.shape == (1,) + assert X.ndim == 2 and X2.ndim == 2 + assert X.shape[-1] == X2.shape[-1] + + if normalized_laplacian: + d = X.shape[-1] + lengthscale = lengthscale / sqrt(d) + + # For TensorFlow, we need to explicitly cast the distances to double. + # Note: if we use B.dtype_float(X) instead of float_like(X), it gives + # float16 and TensorFlow is still complaining. + hamming_distances = B.cast(float_like(X), hamming_distance(X, X2)) + + return B.tanh(lengthscale**2 / 2) ** hamming_distances diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index d16f7310..72c87a48 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -6,13 +6,23 @@ import sys from contextlib import contextmanager from importlib import resources as impresources +from itertools import combinations import einops import lab as B -from beartype.typing import Callable, Generator, List, Set, Tuple +import numpy as np +from beartype.typing import Any, Callable, Generator, List, Optional, Set, Tuple, Union +from plum import ModuleType, resolve_type_hint from geometric_kernels import resources -from geometric_kernels.lab_extras import get_random_state, restore_random_state +from geometric_kernels.lab_extras import ( + count_nonzero, + get_random_state, + logical_xor, + restore_random_state, +) + +EagerTensor = ModuleType("tensorflow.python.framework.ops", "EagerTensor") def chain(elements: B.Numeric, repetitions: List[int]) -> B.Numeric: @@ -291,6 +301,22 @@ def get_resource_file_path(filename: str): yield path +def hamming_distance(x1: B.Bool, x2: B.Bool): + """ + Hamming distance between two batches of boolean vectors. + + :param x1: + Array of any backend, of shape [N, D]. + :param x2: + Array of any backend, of shape [M, D]. + + :return: + An array of shape [N, M] whose entry n, m contains the Hamming distance + between x1[n, :] and x2[m, :]. + """ + return count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) + + def log_binomial(n: B.Int, k: B.Int) -> B.Float: """ Compute the logarithm of the binomial coefficient. @@ -306,3 +332,89 @@ def log_binomial(n: B.Int, k: B.Int) -> B.Float: assert B.all(0 <= k <= n) return B.loggamma(n + 1) - B.loggamma(k + 1) - B.loggamma(n - k + 1) + + +def binary_vectors_and_subsets(d: int): + """ + Generates all possible binary vectors of size d and all possible subsets of + the set $\{0, .., d-1\}$ as a byproduct. + + :param d: + The dimension of binary vectors and the size of the set to take subsets of. + + :return: + A tuple (x, combs), where x is a matrix of size (2**d, d) whose rows + are all possible binary vectors of size d, and combs is a list of all + possible subsets of the set $\{0, .., d-1\}$, each subset being + represented by a list of integers itself. + + """ + x = np.zeros((2**d, d), dtype=bool) + combs = [] + i = 0 + for level in range(d + 1): + for cur_combination in combinations(range(d), level): + indices = list(cur_combination) + combs.append(indices) + x[i, indices] = 1 + i += 1 + + return x, combs + + +def np_to_backend(value: B.NPNumeric, backend: str): + if backend == "tensorflow": + import tensorflow as tf + + return tf.convert_to_tensor(value) + elif backend in ["torch", "pytorch"]: + import torch + + return torch.tensor(value) + elif backend == "numpy": + return value + elif backend == "jax": + import jax.numpy as jnp + + return jnp.array(value) + else: + raise ValueError("Unknown backend: {}".format(backend)) + + +def array_type(backend: str): + if backend == "tensorflow": + return resolve_type_hint(Union[B.TFNumeric, EagerTensor]) + elif backend in ["torch", "pytorch"]: + return resolve_type_hint(B.TorchNumeric) + elif backend == "numpy": + return resolve_type_hint(B.NPNumeric) + elif backend == "jax": + return resolve_type_hint(B.JAXNumeric) + else: + raise ValueError("Unknown backend: {}".format(backend)) + + +def check_function_with_backend( + backend: str, + result: Any, + f: Callable, + *args: B.NPNumeric, + compare_to_result: Optional[Callable] = None, + atol=1e-5, +): + """ + 1. Casts the arguments `*args` to the backend `backend`. + 2. Runs the function `f` on the casted arguments. + 3. Checks that the result is of the backend `backend`. + 4. Checks that the result, casted back to numpy backend, coincides + with the given `result`. + """ + + args_casted = [np_to_backend(arg, backend) for arg in args] + f_output = f(*args_casted) + assert isinstance(f_output, array_type(backend)) + if compare_to_result is None: + # assert np.allclose(B.to_numpy(f_output), result, atol=atol) + np.testing.assert_allclose(B.to_numpy(f_output), result, atol=atol) + else: + assert compare_to_result(result, f_output) diff --git a/test_requirements.txt b/test_requirements.txt index 81e7b33f..56873988 100644 --- a/test_requirements.txt +++ b/test_requirements.txt @@ -15,3 +15,6 @@ pytest # pytest-cov nbmake mypy + +# For running some tests +scikit-learn diff --git a/tests/spaces/test_hypercube.py b/tests/spaces/test_hypercube.py new file mode 100644 index 00000000..775e9a53 --- /dev/null +++ b/tests/spaces/test_hypercube.py @@ -0,0 +1,160 @@ +""" +In `test_call_eigenfunctions` we only check the the eigenfunction evaluation +runs, returns the right type, and the shape of the result is correct. The fact +that the values are correct should follow from other tests: that +""" + +import lab as B +import numpy as np +import pytest +from opt_einsum import contract as einsum +from plum import Tuple + +from geometric_kernels.kernels import MaternGeometricKernel +from geometric_kernels.spaces import Hypercube +from geometric_kernels.utils.special_functions import hypercube_heat_kernel +from geometric_kernels.utils.utils import ( + binary_vectors_and_subsets, + chain, + check_function_with_backend, +) + + +@pytest.fixture(params=[1, 2, 3, 5, 10]) +def inputs(request) -> Tuple[B.Numeric]: + d = request.param + space = Hypercube(d) + key = np.random.RandomState() + N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + num_levels = min(space.dim + 1, 5) + eigenfunctions = space.get_eigenfunctions(num_levels) + return space, eigenfunctions, X, X2 + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_call_eigenfunctions(inputs: Tuple[B.NPNumeric, B.NPNumeric], backend): + _, eigenfunctions, X, _ = inputs + + check_function_with_backend( + backend, + (X.shape[0], eigenfunctions.num_eigenfunctions), + lambda x: eigenfunctions(x), + X, + compare_to_result=lambda res, f_out: f_out.shape == res, + ) + + +def test_numbers_of_eigenfunctions(inputs): + space, eigenfunctions, _, _ = inputs + num_levels = eigenfunctions.num_levels + assert len(eigenfunctions.num_eigenfunctions_per_level) == num_levels + assert eigenfunctions.num_eigenfunctions_per_level[0] == 1 + if num_levels == space.dim + 1: + assert eigenfunctions.num_eigenfunctions == 2**space.dim + + for i in range(num_levels): + assert eigenfunctions.num_eigenfunctions_per_level[i] > 0 + + num_eigenfunctions_manual = sum(eigenfunctions.num_eigenfunctions_per_level) + assert num_eigenfunctions_manual == eigenfunctions.num_eigenfunctions + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_orthonormality(inputs, backend): + space, _, _, _ = inputs + + if space.dim > 5: + pytest.skip("Test is too slow for dim > 5") + + eigenfunctions = space.get_eigenfunctions(space.dim + 1) + + input, _ = binary_vectors_and_subsets(space.dim) + + # Eigenfunctions should be orthonormal with respect to the inner product + # = 2**(-d) sum_i x_i y_i. + check_function_with_backend( + backend, + np.eye(2**space.dim) * 2**space.dim, + lambda x: B.matmul(B.T(eigenfunctions(x)), eigenfunctions(x)), + input, + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_weighted_outerproduct_with_addition_theorem(inputs, backend): + _, eigenfunctions, X, X2 = inputs + num_levels = eigenfunctions.num_levels + + weights = np.random.rand(num_levels, 1) + chained_weights = chain( + weights.squeeze(), eigenfunctions.num_eigenfunctions_per_level + ) + + Phi_X = eigenfunctions(X) + Phi_X2 = eigenfunctions(X2) + result = einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) + + check_function_with_backend( + backend, result, eigenfunctions.weighted_outerproduct, weights, X, X2 + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_weighted_outerproduct_with_addition_theorem_one_input(inputs, backend): + _, eigenfunctions, X, _ = inputs + num_levels = eigenfunctions.num_levels + + weights = np.random.rand(num_levels, 1) + + result = eigenfunctions.weighted_outerproduct(weights, X, X) + + check_function_with_backend( + backend, + result, + eigenfunctions.weighted_outerproduct, + weights, + X, + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_weighted_outerproduct_diag(inputs, backend): + _, eigenfunctions, X, _ = inputs + num_levels = eigenfunctions.num_levels + + weights = np.random.rand(num_levels, 1) + + result = np.diag(eigenfunctions.weighted_outerproduct(weights, X, X)) + + check_function_with_backend( + backend, + result, + eigenfunctions.weighted_outerproduct_diag, + weights, + X, + ) + + +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_against_analytic_heat_kernel(inputs, lengthscale, backend): + space, _, X, X2 = inputs + lengthscale = np.array([lengthscale]) + result = hypercube_heat_kernel(lengthscale, X, X2) + + kernel = MaternGeometricKernel(space) + + check_function_with_backend( + backend, + result, + lambda nu, lengthscale, X, X2: kernel.K( + {"nu": nu, "lengthscale": lengthscale}, X, X2 + ), + np.array([np.inf]), + lengthscale, + X, + X2, + atol=1e-2, + ) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py new file mode 100644 index 00000000..d0d72f70 --- /dev/null +++ b/tests/utils/test_special_functions.py @@ -0,0 +1,142 @@ +from math import comb, log, tanh + +import lab as B +import numpy as np +import pytest +from sklearn.metrics.pairwise import rbf_kernel + +from geometric_kernels.spaces import Hypercube +from geometric_kernels.utils.special_functions import ( + hypercube_heat_kernel, + kravchuk_normalized, + walsh_function, +) +from geometric_kernels.utils.utils import ( + binary_vectors_and_subsets, + check_function_with_backend, + hamming_distance, +) + + +@pytest.fixture(params=[1, 2, 3, 5, 10]) +def all_xs_and_combs(request): + """ + Returns a tuple (d, x, combs) where: + - d is an integer equal to request.param + - x is a 2**d x d boolean matrix with all possible binary vectors of length d + - combs is a list of all possible combinations of indices of x. + """ + d = request.param + + x, combs = binary_vectors_and_subsets(d) + + return d, x, combs + + +def walsh_matrix(d, combs, x): + return B.stack(*[walsh_function(d, comb, x) for comb in combs]) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_walsh_functions(all_xs_and_combs, backend): + d, x, combs = all_xs_and_combs + + # Checks that Walsh functions are orthogonal + check_function_with_backend( + backend, + 2**d * np.eye(2**d), + lambda x: B.matmul(walsh_matrix(d, combs, x), B.T(walsh_matrix(d, combs, x))), + x, + ) + + # Checks that Walsh functions only take values in {-1, 1} + check_function_with_backend( + backend, np.ones((2**d, 2**d)), lambda x: B.abs(walsh_matrix(d, combs, x)), x + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_kravchuk_polynomials(all_xs_and_combs, backend): + d, x, combs = all_xs_and_combs + + x0 = np.zeros((1, d), dtype=bool) + + cur_ind = 0 + for j in range(d + 1): + num_walsh = comb(d, j) + + result = np.sum( + walsh_matrix(d, combs, x)[cur_ind : cur_ind + num_walsh, :], + axis=0, + keepdims=True, + ) + + # Checks that Kravchuk polynomials coincide with certain sums of + # Walsh functions. + check_function_with_backend( + backend, + result, + lambda x0, x: comb(d, j) + * kravchuk_normalized(d, j, hamming_distance(x0, x)), + x0, + x, + ) + + cur_ind += num_walsh + + +@pytest.mark.parametrize("d", [1, 5, 10]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hypercube_heat_kernel(d, lengthscale, backend): + space = Hypercube(d) + + key = np.random.RandomState() + N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + gamma = -log(tanh(lengthscale**2 / 2)) + result = rbf_kernel(X, X2, gamma=gamma) + + # Checks that the heat kernel on the hypercube coincides with the RBF kernel + # restricted onto binary vectors, with appropriately redefined length scale. + check_function_with_backend( + backend, + result, + lambda lengthscale, X, X2: hypercube_heat_kernel( + lengthscale, X, X2, normalized_laplacian=False + ), + np.array([lengthscale]), + X, + X2, + atol=1e-2, + ) + + if d > 5: + X_first = X[0:1, :3] + X2_first = X2[0:1, :3] + X_second = X[0:1, 3:] + X2_second = X2[0:1, 3:] + + K_first = hypercube_heat_kernel( + np.array([lengthscale]), X_first, X2_first, normalized_laplacian=False + ) + K_second = hypercube_heat_kernel( + np.array([lengthscale]), X_second, X2_second, normalized_laplacian=False + ) + + result = K_first * K_second + + # Checks that the heat kernel of the product is equal to the product + # of heat kernels. + check_function_with_backend( + backend, + result, + lambda lengthscale, X, X2: hypercube_heat_kernel( + lengthscale, X, X2, normalized_laplacian=False + ), + np.array([lengthscale]), + X[0:1, :], + X2[0:1, :], + ) diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py new file mode 100644 index 00000000..fdb7cfa3 --- /dev/null +++ b/tests/utils/test_utils.py @@ -0,0 +1,113 @@ +import numpy as np +import pytest + +from geometric_kernels.utils.utils import ( + binary_vectors_and_subsets, + check_function_with_backend, + hamming_distance, + log_binomial, +) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hamming_distance(backend): + + x1 = np.array([[1, 0, 1]], dtype=bool) + + x2 = np.array([[0, 0, 1]], dtype=bool) + + check_function_with_backend(backend, np.array([[1]]), hamming_distance, x1, x2) + check_function_with_backend(backend, np.array([[0]]), hamming_distance, x1, x1) + check_function_with_backend(backend, np.array([[0]]), hamming_distance, x2, x2) + check_function_with_backend(backend, np.array([[1]]), hamming_distance, x2, x1) + + x1 = np.asarray( + [ + [0, 0, 0, 1, 0], + [1, 0, 0, 0, 0], + [1, 1, 1, 1, 0], + [1, 1, 1, 1, 1], + [0, 1, 0, 1, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ], + dtype=bool, + ) + + x2 = np.asarray( + [ + [1, 1, 1, 0, 0], + [1, 0, 1, 0, 0], + [1, 0, 1, 0, 1], + ], + dtype=bool, + ) + + ham_x1_x2 = np.asarray( + [ + [4, 3, 4], + [2, 1, 2], + [1, 2, 3], + [2, 3, 2], + [3, 4, 5], + [3, 2, 3], + [3, 2, 3], + [3, 2, 3], + ], + dtype=int, + ) + + ham_x1_x1 = np.asarray( + [ + [0, 2, 3, 4, 1, 1, 1, 1], + [2, 0, 3, 4, 3, 1, 1, 1], + [3, 3, 0, 1, 2, 4, 4, 4], + [4, 4, 1, 0, 3, 5, 5, 5], + [1, 3, 2, 3, 0, 2, 2, 2], + [1, 1, 4, 5, 2, 0, 0, 0], + [1, 1, 4, 5, 2, 0, 0, 0], + [1, 1, 4, 5, 2, 0, 0, 0], + ], + dtype=int, + ) + + ham_x2_x2 = np.asarray( + [ + [0, 1, 2], + [1, 0, 1], + [2, 1, 0], + ], + dtype=int, + ) + + check_function_with_backend(backend, ham_x1_x2, hamming_distance, x1, x2) + check_function_with_backend(backend, ham_x1_x1, hamming_distance, x1, x1) + check_function_with_backend(backend, ham_x2_x2, hamming_distance, x2, x2) + check_function_with_backend(backend, ham_x1_x2.T, hamming_distance, x2, x1) + + +@pytest.mark.parametrize("n", [0, 1, 2, 3, 4, 5]) +def test_log_binomial(n): + for k in range(n + 1): + assert np.isclose(np.log(np.math.comb(n, k)), log_binomial(n, k), atol=1e-10) + + +@pytest.mark.parametrize("d", [0, 1, 2, 3, 5, 10]) +def test_binary_vectors_and_subsets(d): + x, subsets = binary_vectors_and_subsets(d) + + assert isinstance(x, np.ndarray) + assert isinstance(subsets, list) + + assert x.shape == (2**d, d) + assert x.dtype == bool + assert len(subsets) == 2**d + + for i in range(2**d): + xi_alt = np.zeros(d, dtype=bool) + assert isinstance(subsets[i], list) + xi_alt[subsets[i]] = True + assert np.all(x[i] == xi_alt) + for j in range(i + 1, 2**d): + assert np.any(x[i] != x[j]) From 2e4a5634155a9d1ffed049ae95c4d70031787c46 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Fri, 9 Aug 2024 23:10:19 +0200 Subject: [PATCH 06/24] Improved numerical stability for weighted_outerproduct(_diag) of Hypercube and polishing docstrings. --- docs/examples/Hypercube.nblink | 1 + docs/examples/examples.rst | 3 +- docs/references.bib | 14 ++++ geometric_kernels/spaces/hypercube.py | 75 +++++++++++++------ geometric_kernels/utils/special_functions.py | 22 +++--- geometric_kernels/utils/utils.py | 52 +++++++++++-- tests/spaces/test_hypercube.py | 77 +++++++++++++++++--- tests/utils/test_special_functions.py | 10 +-- tests/utils/test_utils.py | 12 ++- 9 files changed, 211 insertions(+), 55 deletions(-) create mode 100644 docs/examples/Hypercube.nblink diff --git a/docs/examples/Hypercube.nblink b/docs/examples/Hypercube.nblink new file mode 100644 index 00000000..6c7ec1fc --- /dev/null +++ b/docs/examples/Hypercube.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/Hypercube.ipynb"} \ No newline at end of file diff --git a/docs/examples/examples.rst b/docs/examples/examples.rst index 9fb0d87d..9c0289ea 100644 --- a/docs/examples/examples.rst +++ b/docs/examples/examples.rst @@ -8,10 +8,11 @@ Spaces Graph Hyperbolic + Hypercube Hypersphere Mesh - SpecialOrthogonal SPD + SpecialOrthogonal SpecialUnitary Torus diff --git a/docs/references.bib b/docs/references.bib index 0307f4a6..b33311ad 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -121,4 +121,18 @@ @article{canzani2013 author={Canzani, Yaiza}, journal={Lecture Notes available at: http://www.math.harvard.edu/canzani/docs/Laplacian.pdf}, year={2013} +} + +@book{macwilliams1977, + title={The theory of error-correcting codes}, + author={MacWilliams, Florence Jessie and Sloane, Neil James Alexander}, + year={1977}, + publisher={Elsevier} +} + +@inproceedings{borovitskiy2023, + title={Isotropic Gaussian Processes on Finite Spaces of Graphs}, + author={Borovitskiy, Viacheslav and Karimi, Mohammad Reza and Somnath, Vignesh Ram and Krause, Andreas}, + booktitle={International Conference on Artificial Intelligence and Statistics}, + year={2023}, } \ No newline at end of file diff --git a/geometric_kernels/spaces/hypercube.py b/geometric_kernels/spaces/hypercube.py index 0b7ab007..512af2f6 100644 --- a/geometric_kernels/spaces/hypercube.py +++ b/geometric_kernels/spaces/hypercube.py @@ -20,37 +20,27 @@ kravchuk_normalized, walsh_function, ) -from geometric_kernels.utils.utils import chain, hamming_distance +from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial class WalshFunctions(EigenfunctionsWithAdditionTheorem): r""" - Eigenfunctions of graph Laplacian on the hypercube $C = \{0, 1\}^d$ are - Walsh functions $w_T: C \to \{-1, 1\}$ given by + Eigenfunctions of graph Laplacian on the hypercube $C^d = \{0, 1\}^d$ are + Walsh functions $w_T: C^d \to \{-1, 1\}$ given by - .. math:: w_T(x_1, .., x_d) = (-1)^{\sum_{i \in T} x_i}, + .. math:: w_T(x_0, .., x_{d-1}) = (-1)^{\sum_{i \in T} x_i}, - enumerated by all possible subsets $T$ of the set $\{1, .., d\}$. - - .. note:: - Since the degree matrix is a constant multiple of the identity, all - types of the graph Laplacian coincide on the hypercube up to a constant. + enumerated by all possible subsets $T$ of the set $\{0, .., d-1\}$. Levels are the whole eigenspaces, comprising all Walsh functions $w_T$ with the same cardinality of $T$. The addition theorem for these is based on - dynamically precomputed basis functions equivalent to certain - discretizations of the Kravchuk polynomials. + certain discrete orthogonal polynomials called Kravchuk polynomials. :param dim: Dimension $d$ of the hypercube. :param num_levels: - Specifies the number of levels of the spherical harmonics. - - :todo: - Implement explicit weighted_outerproduct and weighted_outerproduct_diag - which compute the product of weights and binom(d, j) in log scale (for - numerical stability). + Specifies the number of levels of the Walsh functions. """ def __init__(self, dim: int, num_levels: int) -> None: @@ -98,6 +88,42 @@ def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: ] return B.concat(*values, axis=1) # [N, L] + def weighted_outerproduct( + self, + weights: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, # type: ignore + **kwargs, + ) -> B.Numeric: + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + result = sum( + B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) + * kravchuk_normalized(self.dim, level, hamming_distances)[..., None] + for level in range(self.num_levels) + ) # [N, N2, 1] + + return B.reshape(result, *result.shape[:-1]) # [N, N2] + + def weighted_outerproduct_diag( + self, weights: B.Numeric, X: B.Numeric, **kwargs + ) -> B.Numeric: + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + result = sum( + B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) + * B.ones(float_like(X), *X.shape[:-1], 1) + for level in range(self.num_levels) + ) # [N, 1] + + return B.reshape(result, *result.shape[:-1]) # [N,] + @property def num_eigenfunctions(self) -> int: if self._num_eigenfunctions is None: @@ -116,7 +142,7 @@ def num_eigenfunctions_per_level(self) -> List[int]: class Hypercube(DiscreteSpectrumSpace): r""" The GeometricKernels space representing the d-dimensional hypercube graph - $C = \{0, 1\}^d$, the combinatorial space of binary vectors of length $d$. + $C^d = \{0, 1\}^d$, the combinatorial space of binary vectors of length $d$. The elements of this space are represented by d-dimensional boolean vectors. @@ -126,8 +152,13 @@ class Hypercube(DiscreteSpectrumSpace): A tutorial on how to use this space is available in the :doc:`Hypersphere.ipynb ` notebook. + .. note:: + Since the degree matrix is a constant multiple of the identity, all + types of the graph Laplacian coincide on the hypercube up to a constant, + we choose the normalized Laplacian for numerical stability. + :param dim: - Dimension $d$ of the hypercube $C = \{0, 1\}^d$, a positive integer. + Dimension $d$ of the hypercube $C^d = \{0, 1\}^d$, a positive integer. .. admonition:: Citation @@ -150,13 +181,13 @@ def dimension(self) -> int: 0-dimensional throughout GeometricKernels, we make an exception for the hypercube. This is because it helps maintain good behavior of Matérn kernels with the usual values of the smoothness parameter - nu, i.e. nu = 1/2, nu=3/2, nu=5/2. + nu, i.e. nu = 1/2, nu = 3/2, nu = 5/2. """ return self.dim def get_eigenfunctions(self, num: int) -> Eigenfunctions: """ - Returns the :class:`~.SphericalHarmonics` object with `num` levels. + Returns the :class:`~.WalshFunctions` object with `num` levels. :param num: Number of levels. @@ -186,7 +217,7 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: def random(self, key: B.RandomState, number: int) -> B.Numeric: r""" - Sample uniformly random points on the hypercube $C = \{0, 1\}^d$. + Sample uniformly random points on the hypercube $C^d = \{0, 1\}^d$. Always returns [N, D] boolean array of the `key`'s backend. diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index b1a0e07b..471a05f1 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -1,3 +1,7 @@ +""" +Special mathematical functions used in the library. +""" + from math import sqrt import lab as B @@ -28,7 +32,7 @@ def walsh_function(d: int, combination: List[int], x: B.Bool) -> B.Float: A subset of the set $\{0, .., d-1\}$ determining the particular Walsh function. A list of integers. :param x: - The batch of binary vectors $x = (x_0, .., x_{d-1})$ of shape [N, d]. + A batch of binary vectors $x = (x_0, .., x_{d-1})$ of shape [N, d]. :return: The value of the Walsh function $w_T(x)$ evaluated for every $x$ in the @@ -53,28 +57,28 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: .. math:: G_{d, j, m} = \sum_{T \subseteq \{0, .., d-1\}, |T| = j} w_T(x). - Here $w_T$ are the Walsh functions on the hypercube $C = \{0, 1\}^d$ and - $x \in C$ is an arbitrary binary vector with $m$ ones (the right-hand side - does not depend on the choice of such vector). + Here $w_T$ are the Walsh functions on the hypercube $C^d = \{0, 1\}^d$ and + $x \in C^d$ is an arbitrary binary vector with $m$ ones (the right-hand side + does not depend on the choice of a particular vector of the kind). .. note:: We are using the three term recurrence relation to compute the Kravchuk polynomials. Cf. Equation (60) in MacWilliams and Sloane "The Theory of Error-Correcting Codes", 1977. The parameters q and \gamma from - MacWilliams and Sloane are set to be q = 2; \gamma = q - 1 = 1. + :cite:t:`macwilliams1977` are set to be q = 2; \gamma = q - 1 = 1. .. note:: - We use the fact that $G_{d, j, 0} = binom{d}{j}$. + We use the fact that $G_{d, j, 0} = \binom{d}{j}$. :param d: The degree of Kravhuk polynomial, an integer d > 0. - Maps to n in MacWilliams and Sloane. + Maps to n in :cite:t:`macwilliams1977`. :param j: d The order of Kravhuk polynomial, an integer 0 <= j <= d. - Maps to k in MacWilliams and Sloane. + Maps to k in :cite:t:`macwilliams1977`. :param m: The independent variable, an integer 0 <= m <= d. - Maps to x in MacWilliams and Sloane. + Maps to x in :cite:t:`macwilliams1977`. :return: $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial. diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 72c87a48..46697897 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -312,7 +312,7 @@ def hamming_distance(x1: B.Bool, x2: B.Bool): :return: An array of shape [N, M] whose entry n, m contains the Hamming distance - between x1[n, :] and x2[m, :]. + between x1[n, :] and x2[m, :]. It is of the same backend as x1 and x2. """ return count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) @@ -335,7 +335,7 @@ def log_binomial(n: B.Int, k: B.Int) -> B.Float: def binary_vectors_and_subsets(d: int): - """ + r""" Generates all possible binary vectors of size d and all possible subsets of the set $\{0, .., d-1\}$ as a byproduct. @@ -347,7 +347,6 @@ def binary_vectors_and_subsets(d: int): are all possible binary vectors of size d, and combs is a list of all possible subsets of the set $\{0, .., d-1\}$, each subset being represented by a list of integers itself. - """ x = np.zeros((2**d, d), dtype=bool) combs = [] @@ -363,6 +362,20 @@ def binary_vectors_and_subsets(d: int): def np_to_backend(value: B.NPNumeric, backend: str): + """ + Converts a numpy array to the desired backend. + + :param value: + A numpy array. + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + + :raises ValueError: + If the backend is not recognized. + + :return: + The array `value` converted to the desired backend. + """ if backend == "tensorflow": import tensorflow as tf @@ -382,6 +395,15 @@ def np_to_backend(value: B.NPNumeric, backend: str): def array_type(backend: str): + """ + Returns the array type corresponding to the given backend. + + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + + :return: + The array type corresponding to the given backend. + """ if backend == "tensorflow": return resolve_type_hint(Union[B.TFNumeric, EagerTensor]) elif backend in ["torch", "pytorch"]: @@ -400,14 +422,32 @@ def check_function_with_backend( f: Callable, *args: B.NPNumeric, compare_to_result: Optional[Callable] = None, - atol=1e-5, + atol=1e-4, ): """ 1. Casts the arguments `*args` to the backend `backend`. 2. Runs the function `f` on the casted arguments. 3. Checks that the result is of the backend `backend`. - 4. Checks that the result, casted back to numpy backend, coincides - with the given `result`. + 4. If no `compare_to_result` kwarg is provided, checks that the result, + casted back to numpy backend, coincides with the given `result`. + If `compare_to_result` is provided, checks if + `compare_to_result(result, f_output)` is True. + + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + :param result: + The expected result of the function, if no `compare_to_result` kwarg is + provided, expected to be a numpy array. Otherwise, can be anything. + :param f: + The backend-independent function to run. + :param args: + The arguments to pass to the function `f`, expected to be numpy arrays. + :param compare_to_result: + A function that takes two arguments, the computed result and the + expected result, and returns a boolean. + :param atol: + The absolute tolerance to use when comparing the computed result with + the expected result. """ args_casted = [np_to_backend(arg, backend) for arg in args] diff --git a/tests/spaces/test_hypercube.py b/tests/spaces/test_hypercube.py index 775e9a53..aa945e3b 100644 --- a/tests/spaces/test_hypercube.py +++ b/tests/spaces/test_hypercube.py @@ -1,9 +1,3 @@ -""" -In `test_call_eigenfunctions` we only check the the eigenfunction evaluation -runs, returns the right type, and the shape of the result is correct. The fact -that the values are correct should follow from other tests: that -""" - import lab as B import numpy as np import pytest @@ -22,14 +16,22 @@ @pytest.fixture(params=[1, 2, 3, 5, 10]) def inputs(request) -> Tuple[B.Numeric]: + """ + Returns a tuple (space, eigenfunctions, X, X2) where: + - space is a Hypercube object with dimension equal to request.param, + - eigenfunctions is the respective Eigenfunctions object with at most 5 levels, + - X is a random sample of random size from the space, + - X2 is another random sample of random size from the space. + """ d = request.param space = Hypercube(d) + eigenfunctions = space.get_eigenfunctions(min(space.dim + 1, 5)) + key = np.random.RandomState() N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) key, X = space.random(key, N) key, X2 = space.random(key, N2) - num_levels = min(space.dim + 1, 5) - eigenfunctions = space.get_eigenfunctions(num_levels) + return space, eigenfunctions, X, X2 @@ -37,6 +39,7 @@ def inputs(request) -> Tuple[B.Numeric]: def test_call_eigenfunctions(inputs: Tuple[B.NPNumeric, B.NPNumeric], backend): _, eigenfunctions, X, _ = inputs + # Check that the eigenfunctions can be called, returning the right type and shape. check_function_with_backend( backend, (X.shape[0], eigenfunctions.num_eigenfunctions), @@ -49,15 +52,22 @@ def test_call_eigenfunctions(inputs: Tuple[B.NPNumeric, B.NPNumeric], backend): def test_numbers_of_eigenfunctions(inputs): space, eigenfunctions, _, _ = inputs num_levels = eigenfunctions.num_levels + # Check that the length of the `num_eigenfunctions_per_level` list is correct. assert len(eigenfunctions.num_eigenfunctions_per_level) == num_levels + # Check that the first eigenspace is 1-dimensional. assert eigenfunctions.num_eigenfunctions_per_level[0] == 1 + # If the number of levels is maximal, check that the number of + # eigenfunctions is equal to the number of binary vectors of size `space.dim`. if num_levels == space.dim + 1: assert eigenfunctions.num_eigenfunctions == 2**space.dim + # Check that dimensions of eigenspaces are always positive. for i in range(num_levels): assert eigenfunctions.num_eigenfunctions_per_level[i] > 0 num_eigenfunctions_manual = sum(eigenfunctions.num_eigenfunctions_per_level) + # Check that `num_eigenfunctions_per_level` sum up to the total number of + # eigenfunctions. assert num_eigenfunctions_manual == eigenfunctions.num_eigenfunctions @@ -72,8 +82,8 @@ def test_orthonormality(inputs, backend): input, _ = binary_vectors_and_subsets(space.dim) - # Eigenfunctions should be orthonormal with respect to the inner product - # = 2**(-d) sum_i x_i y_i. + # Check that the eigenfunctions are orthonormal with respect to the inner + # product = 2**(-d) sum_i x_i y_i. check_function_with_backend( backend, np.eye(2**space.dim) * 2**space.dim, @@ -96,6 +106,9 @@ def test_weighted_outerproduct_with_addition_theorem(inputs, backend): Phi_X2 = eigenfunctions(X2) result = einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) + # Check that `weighted_outerproduct`, which is based on the addition theorem, + # returns the same result as the direct computation involving individual + # eigenfunctions. check_function_with_backend( backend, result, eigenfunctions.weighted_outerproduct, weights, X, X2 ) @@ -110,6 +123,8 @@ def test_weighted_outerproduct_with_addition_theorem_one_input(inputs, backend): result = eigenfunctions.weighted_outerproduct(weights, X, X) + # Check that `weighted_outerproduct`, when given only X (but not X2), + # uses X2=X. check_function_with_backend( backend, result, @@ -128,6 +143,8 @@ def test_weighted_outerproduct_diag(inputs, backend): result = np.diag(eigenfunctions.weighted_outerproduct(weights, X, X)) + # Check that `weighted_outerproduct_diag` returns the same result as the + # diagonal of the full `weighted_outerproduct`. check_function_with_backend( backend, result, @@ -137,6 +154,43 @@ def test_weighted_outerproduct_diag(inputs, backend): ) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_weighted_outerproduct_against_phi_product(inputs, backend): + _, eigenfunctions, X, X2 = inputs + num_levels = eigenfunctions.num_levels + + sum_phi_phi_for_level = eigenfunctions.phi_product(X, X2) + + weights = np.random.rand(num_levels, 1) + result = B.einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) + + # Check that `weighted_outerproduct`, which for the hypercube has a + # dedicated implementation, returns the same result as the usual way of + # computing the `weighted_outerproduct` (based on the `phi_product` method). + check_function_with_backend( + backend, result, eigenfunctions.weighted_outerproduct, weights, X, X2 + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_weighted_outerproduct_diag_against_phi_product(inputs, backend): + _, eigenfunctions, X, _ = inputs + num_levels = eigenfunctions.num_levels + + phi_product_diag = eigenfunctions.phi_product_diag(X) + + weights = np.random.rand(num_levels, 1) + result = B.einsum("id,ni->n", weights, phi_product_diag) # [N,] + + # Check that `weighted_outerproduct_diag`, which for the hypercube has a + # dedicated implementation, returns the same result as the usual way of + # computing the `weighted_outerproduct_diag` (based on the + # `phi_product_diag` method). + check_function_with_backend( + backend, result, eigenfunctions.weighted_outerproduct_diag, weights, X + ) + + @pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_against_analytic_heat_kernel(inputs, lengthscale, backend): @@ -146,6 +200,9 @@ def test_against_analytic_heat_kernel(inputs, lengthscale, backend): kernel = MaternGeometricKernel(space) + # Check that MaternGeometricKernel on the hypercube with nu=infinity + # coincides with the closed form expression for the heat kernel on the + # hypercube. check_function_with_backend( backend, result, diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index d0d72f70..b4d01589 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -22,8 +22,8 @@ def all_xs_and_combs(request): """ Returns a tuple (d, x, combs) where: - - d is an integer equal to request.param - - x is a 2**d x d boolean matrix with all possible binary vectors of length d + - d is an integer equal to request.param, + - x is a 2**d x d boolean matrix with all possible binary vectors of length d, - combs is a list of all possible combinations of indices of x. """ d = request.param @@ -41,7 +41,7 @@ def walsh_matrix(d, combs, x): def test_walsh_functions(all_xs_and_combs, backend): d, x, combs = all_xs_and_combs - # Checks that Walsh functions are orthogonal + # Check that Walsh functions are orthogonal. check_function_with_backend( backend, 2**d * np.eye(2**d), @@ -49,7 +49,7 @@ def test_walsh_functions(all_xs_and_combs, backend): x, ) - # Checks that Walsh functions only take values in {-1, 1} + # Check that Walsh functions only take values in the set {-1, 1}. check_function_with_backend( backend, np.ones((2**d, 2**d)), lambda x: B.abs(walsh_matrix(d, combs, x)), x ) @@ -72,7 +72,7 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): ) # Checks that Kravchuk polynomials coincide with certain sums of - # Walsh functions. + # the Walsh functions. check_function_with_backend( backend, result, diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py index fdb7cfa3..45b05c0e 100644 --- a/tests/utils/test_utils.py +++ b/tests/utils/test_utils.py @@ -16,6 +16,7 @@ def test_hamming_distance(backend): x2 = np.array([[0, 0, 1]], dtype=bool) + # Check that hamming_distance gives the correct results for the given inputs. check_function_with_backend(backend, np.array([[1]]), hamming_distance, x1, x2) check_function_with_backend(backend, np.array([[0]]), hamming_distance, x1, x1) check_function_with_backend(backend, np.array([[0]]), hamming_distance, x2, x2) @@ -81,6 +82,7 @@ def test_hamming_distance(backend): dtype=int, ) + # Check that hamming_distance gives the correct results for more given inputs. check_function_with_backend(backend, ham_x1_x2, hamming_distance, x1, x2) check_function_with_backend(backend, ham_x1_x1, hamming_distance, x1, x1) check_function_with_backend(backend, ham_x2_x2, hamming_distance, x2, x2) @@ -90,6 +92,8 @@ def test_hamming_distance(backend): @pytest.mark.parametrize("n", [0, 1, 2, 3, 4, 5]) def test_log_binomial(n): for k in range(n + 1): + # Check that log_binomial gives the same result as the log of the + # binomial coefficient (as computed through `np.math.comb`). assert np.isclose(np.log(np.math.comb(n, k)), log_binomial(n, k), atol=1e-10) @@ -97,17 +101,21 @@ def test_log_binomial(n): def test_binary_vectors_and_subsets(d): x, subsets = binary_vectors_and_subsets(d) + # Check the returned values have the correct types. assert isinstance(x, np.ndarray) assert isinstance(subsets, list) + # Check the returned values have the correct shapes. assert x.shape == (2**d, d) assert x.dtype == bool assert len(subsets) == 2**d + # Check that all x[i, :] are different and that they have ones at the + # positions contained in subsets[i] and only there. for i in range(2**d): xi_alt = np.zeros(d, dtype=bool) assert isinstance(subsets[i], list) xi_alt[subsets[i]] = True - assert np.all(x[i] == xi_alt) + assert np.all(x[i, :] == xi_alt) for j in range(i + 1, 2**d): - assert np.any(x[i] != x[j]) + assert np.any(x[i, :] != x[j, :]) From 9fbc5086d1133c1c16e18a55b0c1ab8fd44ba036 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sat, 10 Aug 2024 22:50:32 +0200 Subject: [PATCH 07/24] In check_function_with_backend, switch from isinstance to beartype's is_bearable for type-checking to work with Python 3.8 and Python 3.9 --- geometric_kernels/utils/utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 46697897..b7454dbf 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -11,6 +11,7 @@ import einops import lab as B import numpy as np +from beartype.door import is_bearable from beartype.typing import Any, Callable, Generator, List, Optional, Set, Tuple, Union from plum import ModuleType, resolve_type_hint @@ -452,7 +453,7 @@ def check_function_with_backend( args_casted = [np_to_backend(arg, backend) for arg in args] f_output = f(*args_casted) - assert isinstance(f_output, array_type(backend)) + assert is_bearable(f_output, array_type(backend)) if compare_to_result is None: # assert np.allclose(B.to_numpy(f_output), result, atol=atol) np.testing.assert_allclose(B.to_numpy(f_output), result, atol=atol) From 239c4ebf5de6f15508525dceb2f24bc1c789cad1 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 11 Aug 2024 11:47:12 +0200 Subject: [PATCH 08/24] Allow check_function_with_backend to take non-array inputs --- geometric_kernels/utils/utils.py | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index b7454dbf..7eb1474f 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -11,7 +11,7 @@ import einops import lab as B import numpy as np -from beartype.door import is_bearable +from beartype.door import die_if_unbearable, is_bearable from beartype.typing import Any, Callable, Generator, List, Optional, Set, Tuple, Union from plum import ModuleType, resolve_type_hint @@ -421,7 +421,7 @@ def check_function_with_backend( backend: str, result: Any, f: Callable, - *args: B.NPNumeric, + *args: Any, compare_to_result: Optional[Callable] = None, atol=1e-4, ): @@ -442,7 +442,8 @@ def check_function_with_backend( :param f: The backend-independent function to run. :param args: - The arguments to pass to the function `f`, expected to be numpy arrays. + The arguments to pass to the function `f`, expected to be numpy arrays + or non-array arguments. :param compare_to_result: A function that takes two arguments, the computed result and the expected result, and returns a boolean. @@ -451,11 +452,17 @@ def check_function_with_backend( the expected result. """ - args_casted = [np_to_backend(arg, backend) for arg in args] + args_casted = [] + for arg in args: + if is_bearable(arg, B.Numeric): + # We only expect numpy arrays here + die_if_unbearable(arg, B.NPNumeric) + args_casted.append(np_to_backend(arg, backend)) + else: + args_casted.append(arg) f_output = f(*args_casted) assert is_bearable(f_output, array_type(backend)) if compare_to_result is None: - # assert np.allclose(B.to_numpy(f_output), result, atol=atol) np.testing.assert_allclose(B.to_numpy(f_output), result, atol=atol) else: assert compare_to_result(result, f_output) From 98783db62cd0ece67faa3f4464695d6ea9f60208 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 11 Aug 2024 11:48:23 +0200 Subject: [PATCH 09/24] Speed up kernels on the Hypercube space --- geometric_kernels/spaces/hypercube.py | 55 ++++++++++++++------ geometric_kernels/utils/special_functions.py | 22 ++++++-- tests/utils/test_special_functions.py | 29 +++++++++++ 3 files changed, 87 insertions(+), 19 deletions(-) diff --git a/geometric_kernels/spaces/hypercube.py b/geometric_kernels/spaces/hypercube.py index 512af2f6..a1b8eac9 100644 --- a/geometric_kernels/spaces/hypercube.py +++ b/geometric_kernels/spaces/hypercube.py @@ -68,13 +68,23 @@ def _addition_theorem( hamming_distances = hamming_distance(X, X2) - values = [ - comb(self.dim, level) - * kravchuk_normalized(self.dim, level, hamming_distances)[ - ..., None - ] # [N, N2, 1] - for level in range(self.num_levels) - ] + values = [] + + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = kravchuk_normalized( + self.dim, + level, + hamming_distances, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) # [N, N2] + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + values.append( + comb(self.dim, level) * cur_kravchuk_normalized[..., None] # [N, N2, 1] + ) return B.concat(*values, axis=-1) # [N, N2, L] @@ -100,15 +110,28 @@ def weighted_outerproduct( hamming_distances = hamming_distance(X, X2) - # Instead of multiplying weights by binomial coefficients, we sum their - # logs and then exponentiate the result for numerical stability. - result = sum( - B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) - * kravchuk_normalized(self.dim, level, hamming_distances)[..., None] - for level in range(self.num_levels) - ) # [N, N2, 1] - - return B.reshape(result, *result.shape[:-1]) # [N, N2] + result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = kravchuk_normalized( + self.dim, + level, + hamming_distances, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + # Furthermore, we save the computed Kravchuk polynomials for next iterations. + result += ( + B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) + * cur_kravchuk_normalized + ) + + return result # [N, N2] def weighted_outerproduct_diag( self, weights: B.Numeric, X: B.Numeric, **kwargs diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 471a05f1..60e7d344 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -47,7 +47,13 @@ def walsh_function(d: int, combination: List[int], x: B.Bool) -> B.Float: return (-1) ** count_nonzero(take_along_axis(x, indices, axis=-1), axis=-1) -def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: +def kravchuk_normalized( + d: int, + j: int, + m: B.Int, + kravchuk_normalized_j_minus_1: Optional[B.Float] = None, + kravchuk_normalized_j_minus_2: Optional[B.Float] = None, +) -> B.Float: r""" This function returns $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial defined below. @@ -79,6 +85,12 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: :param m: The independent variable, an integer 0 <= m <= d. Maps to x in :cite:t:`macwilliams1977`. + :param kravchuk_normalized_j_minus_1: + The optional precomputed value of $G_{d, j-1, m}/G_{d, j-1, 0}$, helps + to avoid exponential complexity growth due to the recursion. + :param kravchuk_normalized_j_minus_2: + The optional precomputed value of $G_{d, j-2, m}/G_{d, j-2, 0}$, helps + to avoid exponential complexity growth due to the recursion. :return: $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial. @@ -94,8 +106,12 @@ def kravchuk_normalized(d: int, j: int, m: B.Int) -> B.Float: elif j == 1: return 1 - 2 * m / d else: - rhs_1 = (d - 2 * m) * kravchuk_normalized(d, j - 1, m) - rhs_2 = -(j - 1) * kravchuk_normalized(d, j - 2, m) + if kravchuk_normalized_j_minus_1 is None: + kravchuk_normalized_j_minus_1 = kravchuk_normalized(d, j - 1, m) + if kravchuk_normalized_j_minus_2 is None: + kravchuk_normalized_j_minus_2 = kravchuk_normalized(d, j - 2, m) + rhs_1 = (d - 2 * m) * kravchuk_normalized_j_minus_1 + rhs_2 = -(j - 1) * kravchuk_normalized_j_minus_2 return (rhs_1 + rhs_2) / (d - j + 1) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index b4d01589..f5b68cf1 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -85,6 +85,35 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): cur_ind += num_walsh +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_kravchuk_precomputed(all_xs_and_combs, backend): + d, x, _ = all_xs_and_combs + + x0 = np.zeros((1, d), dtype=bool) + + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for j in range(d + 1): + + cur_kravchuk_normalized = kravchuk_normalized(d, j, hamming_distance(x0, x)) + + # Checks that Kravchuk polynomials coincide with certain sums of + # the Walsh functions. + check_function_with_backend( + backend, + cur_kravchuk_normalized, + lambda x0, x, kn1, kn2: kravchuk_normalized( + d, j, hamming_distance(x0, x), kn1, kn2 + ), + x0, + x, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) + + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + @pytest.mark.parametrize("d", [1, 5, 10]) @pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) From 1cac931e3da85b35c1bc1a1bf533a916748994a0 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 11 Aug 2024 14:12:43 +0200 Subject: [PATCH 10/24] Polish the Hypercube.ipynb notebook and add a theoretical page on the Hypercube space --- docs/theory/hypercube.rst | 108 ++++++++++++++++++++++++++++++++++++++ docs/theory/index.rst | 1 + notebooks/Hypercube.ipynb | 89 +++++++------------------------ 3 files changed, 128 insertions(+), 70 deletions(-) create mode 100644 docs/theory/hypercube.rst diff --git a/docs/theory/hypercube.rst b/docs/theory/hypercube.rst new file mode 100644 index 00000000..a9d1dd1d --- /dev/null +++ b/docs/theory/hypercube.rst @@ -0,0 +1,108 @@ +################################ + Kernels on the Hypercube Graph +################################ + +.. warning:: + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. + + This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2023`. + +========================== +Motivation +========================== + +The :class:`~.spaces.Hypercube` space $C^d$ can be used to model $d$-dimensional *binary vector* inputs. + +There are many settings where inputs are binary vectors or can be represented as such. For instance, upon flattening, binary vectors represent adjacency matrices of *unweighted labeled graphs* [#]_. + +========================== +Structure of the Space +========================== + +The elements of this space—given its `dim` is $d \in \mathbb{Z}_{>0}$—are exactly the binary vectors of length $d$. + +The geometry of this space is simple: it is a graph such that $x, x' \in C^d$ are connected by an edge if and only if they differ in exactly one coordinate (i.e. there is exactly *Hamming distance* $1$ between). + +Being a graph, $C^d$ could also be represented using the general :class:`~.spaces.Graph` space. +However, the number of nodes in $C^d$ is $2^d$, which is exponential in $d$, rendering the general techniques infeasible. + +========================== +Eigenfunctions +========================== + +On graphs, kernels are computed using the eigenfunctions and eigenvalues of the Laplacian. + +The eigenfunctions of the Laplacian on the hypercube graph are the *Walsh functions* [#]_ given analytically by the simple formula +$$ +w_T(x_0, .., x_{d-1}) = (-1)^{\sum_{j \in T} x_j} +$$ +where $x = (x_0, .., x_{d-1}) \in C^d$ and the index $T$ is an arbitrary subset of the set $\{0, .., d-1\}$. + +The corresponding eigenvalues are $\lambda_T = \lambda_{\lvert T \rvert} = 2 \lvert T \rvert / d$, where $\lvert T \rvert$ is the cardinality of $T$. + +However, the problem is that the number of eigenfunctions is $2^d$. +Hence naive truncation of the sum in the kernel formula to a few hundred terms leads to a poor approximation of the kernel for larger $d$. + +========================== +Addition Theorem +========================== + +Much like for the hyperspheres and unlike for the general graphs, there is an :doc:`addition theorem ` for the hypercube graph: + +$$ +\sum_{T \subseteq \{0, .., d-1\}, \lvert T \rvert = j} w_T(x) w_T(x') += +\sum_{T \subseteq \{0, .., d-1\}, \lvert T \rvert = j} w_T(x \oplus x') += +\binom{d}{j} +\widetilde{G}_{d, j, m} +$$ +where $\oplus$ is the elementwise XOR operation, $m$ is the Hamming distance between $x$ and $x'$, and $\widetilde{G}_{d, j, m}$ is the Kravchuk polynomial of degree $d$ and order $j$ normalized such that $\widetilde{G}_{d, j, 0} = 1$, evaluated at $m$. + +Normalized Kravchuk polynomials $\widetilde{G}_{d, j, m}$ satisfy the following three-term recurrence relation +$$ +\widetilde{G}_{d, j, m} += +\frac{d - 2 m}{d - j + 1} \widetilde{G}_{d, j - 1, m} +-\frac{j-1}{d - j + 1} \widetilde{G}_{d, j - 2, m}, +\quad +\widetilde{G}_{d, 0, m} = 1, +\quad +\widetilde{G}_{d, 1, m} = 1 - \frac{2}{d} m, +$$ +which allows for their efficient computation without the need to compute large sums of the individual Walsh functions. + +With that, the kernels on the hypercube graph can be computed efficiently using the formula +$$ +k_{\nu, \kappa}(x, x') += +\frac{1}{C_{\nu, \kappa}} +\sum_{l=0}^{L-1} +\Phi_{\nu, \kappa}(\lambda_l) +\binom{d}{j} \widetilde{G}_{d, j, m} +\qquad +\Phi_{\nu, \kappa}(\lambda) += +\begin{cases} +\left(\frac{2\nu}{\kappa^2} + \lambda\right)^{-\nu-\frac{d}{2}} +& +\nu < \infty \text{ — Matérn} +\\ +e^{-\frac{\kappa^2}{2} \lambda} +& +\nu = \infty \text{ — Heat (RBF)} +\end{cases} +$$ +where $m$ is the Hamming distance between $x$ and $x'$, and $L \leq d + 1$ is the user-controlled number of levels parameters. + +**Notes:** + +#. We define the dimension of the :class:`~.spaces.Hypercube` space $C^d$ to be $d$, in contrast to the graphs represented by the :class:`~.spaces.Graph` space, whose dimension is defined to be $0$. + + Because of this, much like in the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ *are* in fact reasonable values of for the smoothness parameter $\nu$. + +.. rubric:: Footnotes + +.. [#] Every node of a labeled graph is associated with a unique label. Functions on labeled graphs do *not* have to be invariant to permutations of nodes. + +.. [#] Since the hypercube graph $C^d$ is $d$-regular, the unnormalized Laplacian and the symmetric normalized Laplacian coincide up to a multiplication by $d$. Thus their eigenfunctions are the same and eigenvalues coincide up to a multiplication by $d$. For better numerical stability, we use symmetric normalized Laplacian in the implementation and assume its use throughout this page. \ No newline at end of file diff --git a/docs/theory/index.rst b/docs/theory/index.rst index 7d06a475..c7778da1 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -13,3 +13,4 @@ Kernels on product spaces Product kernels Feature maps and sampling + Hypercube graph space diff --git a/notebooks/Hypercube.ipynb b/notebooks/Hypercube.ipynb index 73ad68a7..149e8b43 100644 --- a/notebooks/Hypercube.ipynb +++ b/notebooks/Hypercube.ipynb @@ -21,10 +21,12 @@ "metadata": {}, "source": [ "# Matérn and Heat Kernels on the Hypercube Graph\n", - "This notebook shows how define and evaluate kernels on the hypercube graph $C = \\{0, 1\\}^d$ for modeling data encoded as binary vectors with kernels that respect the geometry of the Hamming distance.\n", + "This notebook shows how define and evaluate kernels on the hypercube graph $C^d = \\{0, 1\\}^d$ for modeling data encoded as binary vectors with kernels that respect the geometry of the Hamming distance.\n", "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the hypercube graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", "\n", + "**Note:** the points on the hypercube $C^d$ are boolean vectors of size $d$ (`array`s of the suitable backend).\n", + "\n", "We use the **numpy** backend here." ] }, @@ -107,7 +109,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First we create a GeometricKernels `space` that corresponds to the 3-dimensional hypercube $C = \\{0, 1\\}^3$." + "First we create a GeometricKernels `space` that corresponds to the 6-dimensional hypercube $C^6 = \\{0, 1\\}^6$." ] }, { @@ -139,7 +141,7 @@ "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", "\n", - "A brief account on theory behind the kernels on graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html)." + "A brief account on theory behind the kernels on the Hypecube space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hypercube.html)." ] }, { @@ -188,14 +190,7 @@ "source": [ "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", "\n", - "**Note:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", - "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", - "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n", - "\n", - "**Note:** consider a graph with the scaled adjacency $\\mathbf{A}' = \\alpha^2 \\mathbf{A}$, for some $\\alpha > 0$.\n", - "Denote the kernel corresponding to $\\mathbf{A}$ by $k_{\\nu, \\kappa}$ and the kernel corresponding to $\\mathbf{A}'$ by $k_{\\nu, \\kappa}'$.\n", - "Then, as apparent from [the theory](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html), for the normalized graph Laplacian we have $k_{\\nu, \\kappa}' (i, j) = k_{\\nu, \\kappa} (i, j)$.\n", - "On the other hand, for the unnormalized graph Laplacian, we have $k_{\\nu, \\kappa}' (i, j) = k_{\\nu, \\alpha \\cdot \\kappa} (i, j)$, i.e. the lengthscale changes." + "**Note:** like in the Euclidean or the manifold case, and unlike the general graph case, the $1/2, 3/2, 5/2$ are reasonable values of $\\nu$." ] }, { @@ -209,6 +204,7 @@ "params_inf = params.copy()\n", "del params\n", "params_32[\"nu\"] = np.array([3/2])\n", + "\n", "params_inf[\"nu\"] = np.array([np.inf])" ] }, @@ -288,7 +284,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -383,6 +379,7 @@ "metadata": {}, "outputs": [], "source": [ + "# original code by moreka (https://github.com/moreka)\n", "nx_graph = nx.hypercube_graph(6)\n", "pos = {}\n", "pos_list = [[3.18462, 1.34985], [3.46898, 2.21925], [3.0926, 0.433815], [2.21637, 1.30873], [2.28051, 0.928812], [2.86498, 2.26308], [2.29255, 1.64284], [2.64033, 2.62609], [2.26249, 0.620019], [1.22333, 1.6272], [1.30126, 1.27321], [1.8951, 2.67092], [3.07142, 3.07337], [2.8847, 1.2473], [1.83961, 2.30481], [1.90441, 1.92474], [2.24187, 3.47925], [1.91185, 1.59387], [0.847931, 2.64534], [0.921474, 2.26993], [2.64087, 1.90506], [2.23761, 0.0143973], [1.22294, 0.92365], [1.61988, 2.26091], [1.34731, 0.295391], [0.310627, 1.32606], [2.25335, 2.88409], [1.90784, 0.846041], [0.816332, 1.90238], [1.33814, 3.17037], [0.921199, 1.20639], [0., 2.22938], [2.55532, 2.28013], [2.16799, 0.321943], [1.5785, 2.6446], [1.24187, 0.594268], [2.14965, 3.18708], [1.85838, 1.23437], [1.28765, 3.48145], [0.835271, 1.58692], [1.57226, 1.90989], [1.27719, 0.], [0.5959, 2.24946], [0.418121, 0.397024], [1.22698, 2.87589], [0.848116, 0.849037], [0.413789, 3.08402], [0.00515571, 1.26256], [3.48101, 1.27272], [2.66405, 1.5921], [3.15933, 2.15967], [2.25775, 2.56393], [2.63577, 0.842368], [1.63869, 1.19036], [2.26401, 1.86592], [1.262, 2.18508], [2.56504, 1.22796], [1.58605, 1.5802], [2.17677, 2.23174], [1.20135, 2.56672], [1.59072, 0.82126], [0.611881, 1.2214], [1.19346, 1.85031], [0.295044, 2.14672]]\n", @@ -395,23 +392,6 @@ " pos[nodes[vert_list[i]]] = pos_list[i]" ] }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "64 64 64 (64,)\n" - ] - } - ], - "source": [ - "print(nx_graph.number_of_nodes(), 2**6, len(pos), values_32.shape)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -421,12 +401,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -445,7 +425,7 @@ "\n", "# Red outline for the base_point:\n", "edgecolors = [(0, 0, 0, 0)]*nx_graph.number_of_nodes()\n", - "# edgecolors[base_point] = (1, 0, 0, 1)\n", + "edgecolors[0] = (1, 0, 0, 1)\n", "\n", "# Save graph layout so that graph appears the same in every plot\n", "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", @@ -483,7 +463,7 @@ "source": [ "## Feature Maps and Sampling\n", "\n", - "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on graphs, i.e. such $\\phi$ that\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on the hypecube $C^d$, i.e. such $\\phi$ that\n", "$$\n", "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", "$$\n", @@ -513,7 +493,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -541,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -588,7 +568,7 @@ " 0.05268298 -0.05268298 0.05268298 -0.03772592 0.03772592 0.03772592\n", " -0.03772592 0.03772592 0.03772592 0.02820844]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.540871972436576e-15\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.1729809684177493e-15\n" ] } ], @@ -607,37 +587,6 @@ "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" ] }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(2, 3) (0, 1)\n" - ] - }, - { - "data": { - "text/plain": [ - "array([], shape=(2, 0), dtype=int64)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# from geometric_kernels.utils.special_functions import walsh_function\n", - "# walsh_function(3, np.asarray([], dtype=int), np.asarray([True, False, True], dtype=bool))\n", - "\n", - "print(np.array([[1,2,3], [4,5,6]]).shape, np.array([], dtype=int)[:, None].shape)\n", - "np.take_along_axis(np.array([[1,2,3], [4,5,6]]), np.array([], dtype=int)[None, :], axis=1)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -659,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -699,7 +648,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -757,7 +706,7 @@ "source": [ "## Citation\n", "\n", - "If you are using graphs and GeometricKernels, please consider citing\n", + "If you are using the Hypercube space and GeometricKernels, please consider citing\n", "\n", "```\n", "@article{mostowsky2024,\n", From cb0122263cdbca6afdd7ccfd3dc36aa0673b37fb Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 11 Aug 2024 14:30:54 +0200 Subject: [PATCH 11/24] Minor refactoring of the new tests --- tests/spaces/test_hypercube.py | 8 ++--- tests/utils/test_special_functions.py | 36 +++++++++++------------ tests/utils/test_utils.py | 42 +++++++++++++-------------- 3 files changed, 43 insertions(+), 43 deletions(-) diff --git a/tests/spaces/test_hypercube.py b/tests/spaces/test_hypercube.py index aa945e3b..ef87e839 100644 --- a/tests/spaces/test_hypercube.py +++ b/tests/spaces/test_hypercube.py @@ -43,7 +43,7 @@ def test_call_eigenfunctions(inputs: Tuple[B.NPNumeric, B.NPNumeric], backend): check_function_with_backend( backend, (X.shape[0], eigenfunctions.num_eigenfunctions), - lambda x: eigenfunctions(x), + lambda X: eigenfunctions(X), X, compare_to_result=lambda res, f_out: f_out.shape == res, ) @@ -80,15 +80,15 @@ def test_orthonormality(inputs, backend): eigenfunctions = space.get_eigenfunctions(space.dim + 1) - input, _ = binary_vectors_and_subsets(space.dim) + X, _ = binary_vectors_and_subsets(space.dim) # Check that the eigenfunctions are orthonormal with respect to the inner # product = 2**(-d) sum_i x_i y_i. check_function_with_backend( backend, np.eye(2**space.dim) * 2**space.dim, - lambda x: B.matmul(B.T(eigenfunctions(x)), eigenfunctions(x)), - input, + lambda X: B.matmul(B.T(eigenfunctions(X)), eigenfunctions(X)), + X, ) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index f5b68cf1..86891aae 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -28,36 +28,36 @@ def all_xs_and_combs(request): """ d = request.param - x, combs = binary_vectors_and_subsets(d) + X, combs = binary_vectors_and_subsets(d) - return d, x, combs + return d, X, combs -def walsh_matrix(d, combs, x): - return B.stack(*[walsh_function(d, comb, x) for comb in combs]) +def walsh_matrix(d, combs, X): + return B.stack(*[walsh_function(d, comb, X) for comb in combs]) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_walsh_functions(all_xs_and_combs, backend): - d, x, combs = all_xs_and_combs + d, X, combs = all_xs_and_combs # Check that Walsh functions are orthogonal. check_function_with_backend( backend, 2**d * np.eye(2**d), - lambda x: B.matmul(walsh_matrix(d, combs, x), B.T(walsh_matrix(d, combs, x))), - x, + lambda X: B.matmul(walsh_matrix(d, combs, X), B.T(walsh_matrix(d, combs, X))), + X, ) # Check that Walsh functions only take values in the set {-1, 1}. check_function_with_backend( - backend, np.ones((2**d, 2**d)), lambda x: B.abs(walsh_matrix(d, combs, x)), x + backend, np.ones((2**d, 2**d)), lambda X: B.abs(walsh_matrix(d, combs, X)), X ) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_kravchuk_polynomials(all_xs_and_combs, backend): - d, x, combs = all_xs_and_combs + d, X, combs = all_xs_and_combs x0 = np.zeros((1, d), dtype=bool) @@ -66,7 +66,7 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): num_walsh = comb(d, j) result = np.sum( - walsh_matrix(d, combs, x)[cur_ind : cur_ind + num_walsh, :], + walsh_matrix(d, combs, X)[cur_ind : cur_ind + num_walsh, :], axis=0, keepdims=True, ) @@ -76,10 +76,10 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): check_function_with_backend( backend, result, - lambda x0, x: comb(d, j) - * kravchuk_normalized(d, j, hamming_distance(x0, x)), + lambda x0, X: comb(d, j) + * kravchuk_normalized(d, j, hamming_distance(x0, X)), x0, - x, + X, ) cur_ind += num_walsh @@ -87,25 +87,25 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_kravchuk_precomputed(all_xs_and_combs, backend): - d, x, _ = all_xs_and_combs + d, X, _ = all_xs_and_combs x0 = np.zeros((1, d), dtype=bool) kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for j in range(d + 1): - cur_kravchuk_normalized = kravchuk_normalized(d, j, hamming_distance(x0, x)) + cur_kravchuk_normalized = kravchuk_normalized(d, j, hamming_distance(x0, X)) # Checks that Kravchuk polynomials coincide with certain sums of # the Walsh functions. check_function_with_backend( backend, cur_kravchuk_normalized, - lambda x0, x, kn1, kn2: kravchuk_normalized( - d, j, hamming_distance(x0, x), kn1, kn2 + lambda x0, X, kn1, kn2: kravchuk_normalized( + d, j, hamming_distance(x0, X), kn1, kn2 ), x0, - x, + X, kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2, ) diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py index 45b05c0e..cf1dc376 100644 --- a/tests/utils/test_utils.py +++ b/tests/utils/test_utils.py @@ -12,17 +12,17 @@ @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_hamming_distance(backend): - x1 = np.array([[1, 0, 1]], dtype=bool) + X = np.array([[1, 0, 1]], dtype=bool) - x2 = np.array([[0, 0, 1]], dtype=bool) + X2 = np.array([[0, 0, 1]], dtype=bool) # Check that hamming_distance gives the correct results for the given inputs. - check_function_with_backend(backend, np.array([[1]]), hamming_distance, x1, x2) - check_function_with_backend(backend, np.array([[0]]), hamming_distance, x1, x1) - check_function_with_backend(backend, np.array([[0]]), hamming_distance, x2, x2) - check_function_with_backend(backend, np.array([[1]]), hamming_distance, x2, x1) + check_function_with_backend(backend, np.array([[1]]), hamming_distance, X, X2) + check_function_with_backend(backend, np.array([[0]]), hamming_distance, X, X) + check_function_with_backend(backend, np.array([[0]]), hamming_distance, X2, X2) + check_function_with_backend(backend, np.array([[1]]), hamming_distance, X2, X) - x1 = np.asarray( + X = np.asarray( [ [0, 0, 0, 1, 0], [1, 0, 0, 0, 0], @@ -36,7 +36,7 @@ def test_hamming_distance(backend): dtype=bool, ) - x2 = np.asarray( + X2 = np.asarray( [ [1, 1, 1, 0, 0], [1, 0, 1, 0, 0], @@ -45,7 +45,7 @@ def test_hamming_distance(backend): dtype=bool, ) - ham_x1_x2 = np.asarray( + ham_X_X2 = np.asarray( [ [4, 3, 4], [2, 1, 2], @@ -59,7 +59,7 @@ def test_hamming_distance(backend): dtype=int, ) - ham_x1_x1 = np.asarray( + ham_X_X = np.asarray( [ [0, 2, 3, 4, 1, 1, 1, 1], [2, 0, 3, 4, 3, 1, 1, 1], @@ -73,7 +73,7 @@ def test_hamming_distance(backend): dtype=int, ) - ham_x2_x2 = np.asarray( + ham_X2_X2 = np.asarray( [ [0, 1, 2], [1, 0, 1], @@ -83,10 +83,10 @@ def test_hamming_distance(backend): ) # Check that hamming_distance gives the correct results for more given inputs. - check_function_with_backend(backend, ham_x1_x2, hamming_distance, x1, x2) - check_function_with_backend(backend, ham_x1_x1, hamming_distance, x1, x1) - check_function_with_backend(backend, ham_x2_x2, hamming_distance, x2, x2) - check_function_with_backend(backend, ham_x1_x2.T, hamming_distance, x2, x1) + check_function_with_backend(backend, ham_X_X2, hamming_distance, X, X2) + check_function_with_backend(backend, ham_X_X, hamming_distance, X, X) + check_function_with_backend(backend, ham_X2_X2, hamming_distance, X2, X2) + check_function_with_backend(backend, ham_X_X2.T, hamming_distance, X2, X) @pytest.mark.parametrize("n", [0, 1, 2, 3, 4, 5]) @@ -99,15 +99,15 @@ def test_log_binomial(n): @pytest.mark.parametrize("d", [0, 1, 2, 3, 5, 10]) def test_binary_vectors_and_subsets(d): - x, subsets = binary_vectors_and_subsets(d) + X, subsets = binary_vectors_and_subsets(d) # Check the returned values have the correct types. - assert isinstance(x, np.ndarray) + assert isinstance(X, np.ndarray) assert isinstance(subsets, list) # Check the returned values have the correct shapes. - assert x.shape == (2**d, d) - assert x.dtype == bool + assert X.shape == (2**d, d) + assert X.dtype == bool assert len(subsets) == 2**d # Check that all x[i, :] are different and that they have ones at the @@ -116,6 +116,6 @@ def test_binary_vectors_and_subsets(d): xi_alt = np.zeros(d, dtype=bool) assert isinstance(subsets[i], list) xi_alt[subsets[i]] = True - assert np.all(x[i, :] == xi_alt) + assert np.all(X[i, :] == xi_alt) for j in range(i + 1, 2**d): - assert np.any(x[i, :] != x[j, :]) + assert np.any(X[i, :] != X[j, :]) From 1bd973011eee0793f2fdbf9ea88d54b458c30ea7 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Mon, 12 Aug 2024 19:14:15 +0200 Subject: [PATCH 12/24] Replace opt_einsum's contract with lab's einsum for better backend-independence (#145) Replace opt_einsum's contract with lab's einsum, the latter being a more backend-independent version than the former --- geometric_kernels/feature_maps/probability_densities.py | 3 +-- geometric_kernels/kernels/feature_map.py | 3 +-- geometric_kernels/spaces/eigenfunctions.py | 7 +++---- geometric_kernels/spaces/hyperbolic.py | 3 +-- geometric_kernels/spaces/so.py | 5 ++--- geometric_kernels/spaces/su.py | 5 ++--- tests/kernels/test_product.py | 3 +-- tests/spaces/test_circle.py | 5 ++--- tests/spaces/test_hypersphere.py | 5 ++--- tests/spaces/test_lie_groups.py | 3 +-- 10 files changed, 16 insertions(+), 26 deletions(-) diff --git a/geometric_kernels/feature_maps/probability_densities.py b/geometric_kernels/feature_maps/probability_densities.py index 4f1a73f7..51e524cd 100644 --- a/geometric_kernels/feature_maps/probability_densities.py +++ b/geometric_kernels/feature_maps/probability_densities.py @@ -13,7 +13,6 @@ import lab as B import numpy as np from beartype.typing import Dict, List, Optional, Tuple -from opt_einsum import contract as einsum from sympy import Poly, Product, symbols from geometric_kernels.lab_extras import ( @@ -85,7 +84,7 @@ def student_t_sample( shape_sqrt = B.chol(shape) dtype = dtype or dtype_double(key) key, z = B.randn(key, dtype, *size, n) - z = einsum("...i,ji->...j", z, shape_sqrt) + z = B.einsum("...i,ji->...j", z, shape_sqrt) key, g = B.randgamma( key, diff --git a/geometric_kernels/kernels/feature_map.py b/geometric_kernels/kernels/feature_map.py index c2e531bf..b224be43 100644 --- a/geometric_kernels/kernels/feature_map.py +++ b/geometric_kernels/kernels/feature_map.py @@ -7,7 +7,6 @@ import lab as B import numpy as np from beartype.typing import Dict, Optional -from opt_einsum import contract as einsum from geometric_kernels.feature_maps import FeatureMap from geometric_kernels.kernels.base import BaseGeometricKernel @@ -124,7 +123,7 @@ def K( else: features_X2 = features_X - feature_product = einsum("...no,...mo->...nm", features_X, features_X2) + feature_product = B.einsum("...no,...mo->...nm", features_X, features_X2) return feature_product def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs): diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 91439972..8bdb9055 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -22,7 +22,6 @@ import lab as B from beartype.typing import List, Optional -from opt_einsum import contract as einsum from geometric_kernels.lab_extras import complex_like, is_complex, take_along_axis @@ -106,7 +105,7 @@ def weighted_outerproduct( else: sum_phi_phi_for_level = B.cast(B.dtype(weights), sum_phi_phi_for_level) - return einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) # [N, N2] + return B.einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) # [N, N2] def weighted_outerproduct_diag( self, weights: B.Numeric, X: B.Numeric, **kwargs @@ -132,7 +131,7 @@ def weighted_outerproduct_diag( else: phi_product_diag = B.cast(B.dtype(weights), phi_product_diag) - return einsum("id,ni->n", weights, phi_product_diag) # [N,] + return B.einsum("id,ni->n", weights, phi_product_diag) # [N,] @abc.abstractmethod def phi_product( @@ -301,7 +300,7 @@ def phi_product( X2 = X Phi_X = self.__call__(X, **kwargs) # [N, J] Phi_X2 = self.__call__(X2, **kwargs) # [N2, J] - return einsum("nl,ml->nml", Phi_X, Phi_X2) # [N, N2, J] + return B.einsum("nl,ml->nml", Phi_X, Phi_X2) # [N, N2, J] def phi_product_diag(self, X: B.Numeric, **kwargs): Phi_X = self.__call__(X, **kwargs) # [N, J] diff --git a/geometric_kernels/spaces/hyperbolic.py b/geometric_kernels/spaces/hyperbolic.py index c07593c5..61b57ebc 100644 --- a/geometric_kernels/spaces/hyperbolic.py +++ b/geometric_kernels/spaces/hyperbolic.py @@ -5,7 +5,6 @@ import geomstats as gs import lab as B from beartype.typing import Optional -from opt_einsum import contract as einsum from geometric_kernels.lab_extras import ( complex_like, @@ -134,7 +133,7 @@ def inner_product(self, vector_a, vector_b): p = 1 diagonal = from_numpy(vector_a, [-1.0] * p + [1.0] * q) # (n+1) diagonal = B.cast(B.dtype(vector_a), diagonal) - return einsum("...i,...i->...", diagonal * vector_a, vector_b) + return B.einsum("...i,...i->...", diagonal * vector_a, vector_b) def inv_harish_chandra(self, lam: B.Numeric) -> B.Numeric: lam = B.squeeze(lam, -1) diff --git a/geometric_kernels/spaces/so.py b/geometric_kernels/spaces/so.py index 3ce0d43c..779d275a 100644 --- a/geometric_kernels/spaces/so.py +++ b/geometric_kernels/spaces/so.py @@ -13,7 +13,6 @@ import lab as B import numpy as np from beartype.typing import List, Tuple -from opt_einsum import contract as einsum from geometric_kernels.lab_extras import dtype_double, from_numpy, qr, take_along_axis from geometric_kernels.spaces.eigenfunctions import Eigenfunctions @@ -300,7 +299,7 @@ def random(self, key: B.RandomState, number: int): # explicit parametrization via the double cover SU(2) = S^3 key, sphere_point = B.random.randn(key, dtype_double(key), number, 4) sphere_point /= B.reshape( - B.sqrt(einsum("ij,ij->i", sphere_point, sphere_point)), -1, 1 + B.sqrt(B.einsum("ij,ij->i", sphere_point, sphere_point)), -1, 1 ) x, y, z, w = (B.reshape(sphere_point[..., i], -1, 1) for i in range(4)) @@ -317,7 +316,7 @@ def random(self, key: B.RandomState, number: int): # qr decomposition is not in the lab package, so numpy is used. key, h = B.random.randn(key, dtype_double(key), number, self.n, self.n) q, r = qr(h, mode="complete") - r_diag_sign = B.sign(einsum("...ii->...i", r)) + r_diag_sign = B.sign(B.einsum("...ii->...i", r)) q *= r_diag_sign[:, None] q_det_sign = B.sign(B.det(q)) q[:, :, 0] *= q_det_sign[:, None] diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index c1b0e5b3..a6c89d23 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -12,7 +12,6 @@ import lab as B import numpy as np from beartype.typing import List, Tuple -from opt_einsum import contract as einsum from geometric_kernels.lab_extras import ( complex_conj, @@ -222,7 +221,7 @@ def random(self, key: B.RandomState, number: int): # explicit parametrization via the double cover SU(2) = S_3 key, sphere_point = B.random.randn(key, dtype_double(key), number, 4) sphere_point /= B.reshape( - B.sqrt(einsum("ij,ij->i", sphere_point, sphere_point)), -1, 1 + B.sqrt(B.einsum("ij,ij->i", sphere_point, sphere_point)), -1, 1 ) a = create_complex(sphere_point[..., 0], sphere_point[..., 1]) b = create_complex(sphere_point[..., 2], sphere_point[..., 3]) @@ -235,7 +234,7 @@ def random(self, key: B.RandomState, number: int): key, imag = B.random.randn(key, dtype_double(key), number, self.n, self.n) h = create_complex(real, imag) / B.sqrt(2) q, r = qr(h, mode="complete") - r_diag = einsum("...ii->...i", r) + r_diag = B.einsum("...ii->...i", r) r_diag_inv_phase = complex_conj(r_diag / B.abs(r_diag)) q *= r_diag_inv_phase[:, None] q_det = B.det(q) diff --git a/tests/kernels/test_product.py b/tests/kernels/test_product.py index 7eaa692f..bb345c37 100644 --- a/tests/kernels/test_product.py +++ b/tests/kernels/test_product.py @@ -1,6 +1,5 @@ import lab as B import numpy as np -from opt_einsum import contract as einsum from geometric_kernels.kernels import MaternKarhunenLoeveKernel, ProductGeometricKernel from geometric_kernels.lab_extras.extras import from_numpy @@ -43,7 +42,7 @@ def test_circle_product_eigenfunctions(): weights = B.expand_dims(weights, -1) actual = B.to_numpy(eigenfunctions.weighted_outerproduct(weights, X, X)) - expected = einsum("ni,mi,i->nm", Phi_X, Phi_X2, chained_weights) + expected = B.einsum("ni,mi,i->nm", Phi_X, Phi_X2, chained_weights) np.testing.assert_array_almost_equal(actual, expected) diff --git a/tests/spaces/test_circle.py b/tests/spaces/test_circle.py index fc204936..426ff2a5 100644 --- a/tests/spaces/test_circle.py +++ b/tests/spaces/test_circle.py @@ -3,7 +3,6 @@ import pytest import tensorflow as tf import torch -from opt_einsum import contract as einsum from plum import Tuple from geometric_kernels.kernels import MaternKarhunenLoeveKernel @@ -89,7 +88,7 @@ def test_weighted_outerproduct_with_addition_theorem( Phi_X = eigenfunctions(inputs) Phi_X2 = eigenfunctions(inputs2) - expected = einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) + expected = B.einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) np.testing.assert_array_almost_equal(actual, expected) @@ -124,7 +123,7 @@ def test_weighted_outerproduct_diag_with_addition_theorem( actual = eigenfunctions.weighted_outerproduct_diag(weights, inputs) Phi_X = eigenfunctions(inputs) - expected = einsum("ni,i->n", Phi_X**2, chained_weights) + expected = B.einsum("ni,i->n", Phi_X**2, chained_weights) np.testing.assert_array_almost_equal(B.to_numpy(actual), B.to_numpy(expected)) diff --git a/tests/spaces/test_hypersphere.py b/tests/spaces/test_hypersphere.py index 2aa52b58..860dee00 100644 --- a/tests/spaces/test_hypersphere.py +++ b/tests/spaces/test_hypersphere.py @@ -1,7 +1,6 @@ import lab as B import numpy as np import pytest -from opt_einsum import contract as einsum from plum import Tuple from geometric_kernels.spaces.hypersphere import SphericalHarmonics @@ -77,7 +76,7 @@ def test_weighted_outerproduct_with_addition_theorem( Phi_X = eigenfunctions(inputs) Phi_X2 = eigenfunctions(inputs2) - expected = einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) + expected = B.einsum("ni,ki,i->nk", Phi_X, Phi_X2, chained_weights) np.testing.assert_array_almost_equal(actual, expected) @@ -112,5 +111,5 @@ def test_weighted_outerproduct_diag_with_addition_theorem( actual = eigenfunctions.weighted_outerproduct_diag(weights, inputs) Phi_X = eigenfunctions(inputs) - expected = einsum("ni,i->n", Phi_X**2, chained_weights) + expected = B.einsum("ni,i->n", Phi_X**2, chained_weights) np.testing.assert_array_almost_equal(B.to_numpy(actual), B.to_numpy(expected)) diff --git a/tests/spaces/test_lie_groups.py b/tests/spaces/test_lie_groups.py index bda5a2b6..863580d8 100644 --- a/tests/spaces/test_lie_groups.py +++ b/tests/spaces/test_lie_groups.py @@ -4,7 +4,6 @@ import numpy as np import pytest from numpy.testing import assert_allclose -from opt_einsum import contract as einsum from geometric_kernels.feature_maps import RandomPhaseFeatureMapCompact from geometric_kernels.kernels import MaternKarhunenLoeveKernel @@ -127,6 +126,6 @@ def test_feature_map(group_and_eigf): K_xx = (kernel.K(param, x, x)).real key, embed_x = feature_map(x, param, key=key, normalize=True) - F_xx = (einsum("ni,mi-> nm", embed_x, embed_x.conj())).real + F_xx = (B.einsum("ni,mi-> nm", embed_x, embed_x.conj())).real assert_allclose(K_xx, F_xx, atol=5e-2) From 8f918cca5a4cc86a12be9e131ca529e9f51c719e Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 13 Aug 2024 10:16:37 +0200 Subject: [PATCH 13/24] Hypersphere space small improvements (#142) --- geometric_kernels/spaces/hypersphere.py | 28 +++++++++++-------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/geometric_kernels/spaces/hypersphere.py b/geometric_kernels/spaces/hypersphere.py index f94bb436..f1674102 100644 --- a/geometric_kernels/spaces/hypersphere.py +++ b/geometric_kernels/spaces/hypersphere.py @@ -21,8 +21,8 @@ class SphericalHarmonics(EigenfunctionsWithAdditionTheorem): r""" - Eigenfunctions Laplace-Beltrami operator on the hypersphere correspond - to the spherical harmonics. + Eigenfunctions of the Laplace-Beltrami operator on the hypersphere + correspond to the spherical harmonics. Levels are the whole eigenspaces. @@ -56,7 +56,7 @@ def num_computed_levels(self) -> int: break return num - def __call__(self, X: B.Numeric, **parameters) -> B.Numeric: + def __call__(self, X: B.Numeric, **kwargs) -> B.Numeric: return self._spherical_harmonics(X) def _addition_theorem( @@ -88,7 +88,7 @@ def _addition_theorem( An array of shape [N, N2, L]. """ values = [ - level.addition(X, X2)[..., None] # [N1, N2, 1] + level.addition(X, X2)[..., None] # [N, N2, 1] for level in self._spherical_harmonics.harmonic_levels ] return B.concat(*values, axis=-1) # [N, N2, L] @@ -106,10 +106,10 @@ def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: @property def num_eigenfunctions(self) -> int: if self._num_eigenfunctions is None: - n = 0 - for d in range(self._num_levels): - n += num_harmonics(self.dim + 1, d) - self._num_eigenfunctions = n + J = 0 + for level in range(self.num_levels): + J += num_harmonics(self.dim + 1, level) + self._num_eigenfunctions = J return self._num_eigenfunctions @property @@ -182,14 +182,10 @@ def get_eigenvalues(self, num: int) -> B.Numeric: def get_repeated_eigenvalues(self, num: int) -> B.Numeric: eigenfunctions = SphericalHarmonics(self.dim, num) - eigenvalues_per_level = np.array( - [ - level.eigenvalue() - for level in eigenfunctions._spherical_harmonics.harmonic_levels - ] - ) + eigenvalues_per_level = self.get_eigenvalues(num) + eigenvalues = chain( - eigenvalues_per_level, + B.squeeze(eigenvalues_per_level), eigenfunctions.num_eigenfunctions_per_level, ) # [J,] return B.reshape(eigenvalues, -1, 1) # [J, 1] @@ -241,7 +237,7 @@ def random(self, key: B.RandomState, number: int) -> B.Numeric: Either `np.random.RandomState`, `tf.random.Generator`, `torch.Generator` or `jax.tensor` (representing random state). :param number: - Number of samples to draw. + Number N of samples to draw. :return: An array of `number` uniformly random samples on the space. From 6720588bc32e134293abe777de8fc90c0e031371 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 13 Aug 2024 11:02:33 +0200 Subject: [PATCH 14/24] Change hacky 1 + 0 * m to B.ones(m) in kravchuk_normalized --- geometric_kernels/utils/special_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 60e7d344..714fc1ad 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -102,7 +102,7 @@ def kravchuk_normalized( m = B.cast(B.dtype_float(m), m) if j == 0: - return 1 + 0 * m # 0*m is a hack to make the output have the same shape as m + return B.ones(m) elif j == 1: return 1 - 2 * m / d else: From 2099a96df628ac51ae879632e1e91babfc485d55 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 13 Aug 2024 11:32:40 +0200 Subject: [PATCH 15/24] Rename Hypercube to HypercubeGraph for clarity --- docs/examples/Hypercube.nblink | 1 - docs/examples/HypercubeGraph.nblink | 1 + .../{hypercube.rst => hypercube_graph.rst} | 6 ++--- docs/theory/index.rst | 2 +- geometric_kernels/kernels/matern_kernel.py | 4 ++-- geometric_kernels/spaces/__init__.py | 2 +- .../{hypercube.py => hypercube_graph.py} | 23 ++++++++++--------- geometric_kernels/utils/special_functions.py | 8 +++---- .../{Hypercube.ipynb => HypercubeGraph.ipynb} | 20 ++++++++-------- ...t_hypercube.py => test_hypercube_graph.py} | 18 +++++++-------- tests/utils/test_special_functions.py | 18 +++++++-------- 11 files changed, 52 insertions(+), 51 deletions(-) delete mode 100644 docs/examples/Hypercube.nblink create mode 100644 docs/examples/HypercubeGraph.nblink rename docs/theory/{hypercube.rst => hypercube_graph.rst} (93%) rename geometric_kernels/spaces/{hypercube.py => hypercube_graph.py} (91%) rename notebooks/{Hypercube.ipynb => HypercubeGraph.ipynb} (99%) rename tests/spaces/{test_hypercube.py => test_hypercube_graph.py} (93%) diff --git a/docs/examples/Hypercube.nblink b/docs/examples/Hypercube.nblink deleted file mode 100644 index 6c7ec1fc..00000000 --- a/docs/examples/Hypercube.nblink +++ /dev/null @@ -1 +0,0 @@ -{"path": "../../notebooks/Hypercube.ipynb"} \ No newline at end of file diff --git a/docs/examples/HypercubeGraph.nblink b/docs/examples/HypercubeGraph.nblink new file mode 100644 index 00000000..9e68e558 --- /dev/null +++ b/docs/examples/HypercubeGraph.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/HypercubeGraph.ipynb"} \ No newline at end of file diff --git a/docs/theory/hypercube.rst b/docs/theory/hypercube_graph.rst similarity index 93% rename from docs/theory/hypercube.rst rename to docs/theory/hypercube_graph.rst index a9d1dd1d..34209811 100644 --- a/docs/theory/hypercube.rst +++ b/docs/theory/hypercube_graph.rst @@ -3,7 +3,7 @@ ################################ .. warning:: - You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2023`. @@ -11,7 +11,7 @@ Motivation ========================== -The :class:`~.spaces.Hypercube` space $C^d$ can be used to model $d$-dimensional *binary vector* inputs. +The :class:`~.spaces.HypercubeGraph` space $C^d$ can be used to model $d$-dimensional *binary vector* inputs. There are many settings where inputs are binary vectors or can be represented as such. For instance, upon flattening, binary vectors represent adjacency matrices of *unweighted labeled graphs* [#]_. @@ -97,7 +97,7 @@ where $m$ is the Hamming distance between $x$ and $x'$, and $L \leq d + 1$ is th **Notes:** -#. We define the dimension of the :class:`~.spaces.Hypercube` space $C^d$ to be $d$, in contrast to the graphs represented by the :class:`~.spaces.Graph` space, whose dimension is defined to be $0$. +#. We define the dimension of the :class:`~.spaces.HypercubeGraph` space $C^d$ to be $d$, in contrast to the graphs represented by the :class:`~.spaces.Graph` space, whose dimension is defined to be $0$. Because of this, much like in the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ *are* in fact reasonable values of for the smoothness parameter $\nu$. diff --git a/docs/theory/index.rst b/docs/theory/index.rst index c7778da1..71916b75 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -13,4 +13,4 @@ Kernels on product spaces Product kernels Feature maps and sampling - Hypercube graph space + Hypercube graph space diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 2575cbe4..d0ef1cb0 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -24,7 +24,7 @@ DiscreteSpectrumSpace, Graph, Hyperbolic, - Hypercube, + HypercubeGraph, Hypersphere, Mesh, NoncompactSymmetricSpace, @@ -200,7 +200,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: return min( MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) - elif isinstance(space, Hypercube): + elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: return MaternGeometricKernel._DEFAULT_NUM_LEVELS diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index 1f820709..31698b71 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -11,7 +11,7 @@ from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph from geometric_kernels.spaces.hyperbolic import Hyperbolic -from geometric_kernels.spaces.hypercube import Hypercube +from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.spaces.hypersphere import Hypersphere from geometric_kernels.spaces.lie_groups import CompactMatrixLieGroup from geometric_kernels.spaces.mesh import Mesh diff --git a/geometric_kernels/spaces/hypercube.py b/geometric_kernels/spaces/hypercube_graph.py similarity index 91% rename from geometric_kernels/spaces/hypercube.py rename to geometric_kernels/spaces/hypercube_graph.py index a1b8eac9..0f58b7a6 100644 --- a/geometric_kernels/spaces/hypercube.py +++ b/geometric_kernels/spaces/hypercube_graph.py @@ -1,5 +1,5 @@ """ -This module provides the :class:`Hypercube` space and the respective +This module provides the :class:`HypercubeGraph` space and the respective :class:`~.eigenfunctions.Eigenfunctions` subclass :class:`WalshFunctions`. """ @@ -25,8 +25,9 @@ class WalshFunctions(EigenfunctionsWithAdditionTheorem): r""" - Eigenfunctions of graph Laplacian on the hypercube $C^d = \{0, 1\}^d$ are - Walsh functions $w_T: C^d \to \{-1, 1\}$ given by + Eigenfunctions of graph Laplacian on the hypercube graph $C^d$ whose nodes + are index by binary vectors in $\{0, 1\}^d$ are the Walsh + functions $w_T: C^d \to \{-1, 1\}$ given by .. math:: w_T(x_0, .., x_{d-1}) = (-1)^{\sum_{i \in T} x_i}, @@ -37,7 +38,7 @@ class WalshFunctions(EigenfunctionsWithAdditionTheorem): certain discrete orthogonal polynomials called Kravchuk polynomials. :param dim: - Dimension $d$ of the hypercube. + Dimension $d$ of the hypercube graph. :param num_levels: Specifies the number of levels of the Walsh functions. @@ -162,7 +163,7 @@ def num_eigenfunctions_per_level(self) -> List[int]: return [comb(self.dim, level) for level in range(self.num_levels)] -class Hypercube(DiscreteSpectrumSpace): +class HypercubeGraph(DiscreteSpectrumSpace): r""" The GeometricKernels space representing the d-dimensional hypercube graph $C^d = \{0, 1\}^d$, the combinatorial space of binary vectors of length $d$. @@ -173,15 +174,15 @@ class Hypercube(DiscreteSpectrumSpace): .. note:: A tutorial on how to use this space is available in the - :doc:`Hypersphere.ipynb ` notebook. + :doc:`HypercubeGraph.ipynb ` notebook. .. note:: Since the degree matrix is a constant multiple of the identity, all - types of the graph Laplacian coincide on the hypercube up to a constant, - we choose the normalized Laplacian for numerical stability. + types of the graph Laplacian coincide on the hypercube graph up to a + constant, we choose the normalized Laplacian for numerical stability. :param dim: - Dimension $d$ of the hypercube $C^d = \{0, 1\}^d$, a positive integer. + Dimension $d$ of the hypercube graph $C^d$, a positive integer. .. admonition:: Citation @@ -202,7 +203,7 @@ def dimension(self) -> int: .. note: Although this is a graph, and graphs are generally treated as 0-dimensional throughout GeometricKernels, we make an exception for - the hypercube. This is because it helps maintain good behavior of + HypercubeGraph. This is because it helps maintain good behavior of Matérn kernels with the usual values of the smoothness parameter nu, i.e. nu = 1/2, nu = 3/2, nu = 5/2. """ @@ -240,7 +241,7 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: def random(self, key: B.RandomState, number: int) -> B.Numeric: r""" - Sample uniformly random points on the hypercube $C^d = \{0, 1\}^d$. + Sample uniformly random points on the hypercube graph $C^d$. Always returns [N, D] boolean array of the `key`'s backend. diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 714fc1ad..1e27f5b5 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -63,7 +63,7 @@ def kravchuk_normalized( .. math:: G_{d, j, m} = \sum_{T \subseteq \{0, .., d-1\}, |T| = j} w_T(x). - Here $w_T$ are the Walsh functions on the hypercube $C^d = \{0, 1\}^d$ and + Here $w_T$ are the Walsh functions on the hypercube graph $C^d$ and $x \in C^d$ is an arbitrary binary vector with $m$ ones (the right-hand side does not depend on the choice of a particular vector of the kind). @@ -115,15 +115,15 @@ def kravchuk_normalized( return (rhs_1 + rhs_2) / (d - j + 1) -def hypercube_heat_kernel( +def hypercube_graph_heat_kernel( lengthscale: B.Numeric, X: B.Numeric, X2: Optional[B.Numeric] = None, normalized_laplacian: bool = True, ): """ - Analytic formula for the heat kernel on the hypercube, see Equation (14) in - :cite:t:`borovitskiy2023`. + Analytic formula for the heat kernel on the hypercube graph, see + Equation (14) in :cite:t:`borovitskiy2023`. :param lengthscale: The length scale of the kernel, an array of shape [1]. diff --git a/notebooks/Hypercube.ipynb b/notebooks/HypercubeGraph.ipynb similarity index 99% rename from notebooks/Hypercube.ipynb rename to notebooks/HypercubeGraph.ipynb index 149e8b43..ac36744f 100644 --- a/notebooks/Hypercube.ipynb +++ b/notebooks/HypercubeGraph.ipynb @@ -20,12 +20,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Matérn and Heat Kernels on the Hypercube Graph\n", + "# Matérn and Heat Kernels on HypercubeGraph\n", "This notebook shows how define and evaluate kernels on the hypercube graph $C^d = \\{0, 1\\}^d$ for modeling data encoded as binary vectors with kernels that respect the geometry of the Hamming distance.\n", "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the hypercube graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", "\n", - "**Note:** the points on the hypercube $C^d$ are boolean vectors of size $d$ (`array`s of the suitable backend).\n", + "**Note:** the points on the hypercube graph $C^d$ are boolean vectors of size $d$ (`array`s of the suitable backend).\n", "\n", "We use the **numpy** backend here." ] @@ -88,7 +88,7 @@ "# import geometric_kernels.jax\n", "\n", "# Import a space and an appropriate kernel.\n", - "from geometric_kernels.spaces import Hypercube\n", + "from geometric_kernels.spaces import HypercubeGraph\n", "from geometric_kernels.kernels import MaternGeometricKernel\n", "\n", "# We use networkx to visualize graphs\n", @@ -109,7 +109,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First we create a GeometricKernels `space` that corresponds to the 6-dimensional hypercube $C^6 = \\{0, 1\\}^6$." + "First we create a GeometricKernels `space` that corresponds to the 6-dimensional hypercube graph $C^6 = \\{0, 1\\}^6$." ] }, { @@ -120,7 +120,7 @@ }, "outputs": [], "source": [ - "hypercube = Hypercube(6)" + "hypercube_graph = HypercubeGraph(6)" ] }, { @@ -136,12 +136,12 @@ "source": [ "First, we create a generic Matérn kernel.\n", "\n", - "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `hypercube` we have just created above.\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `hypercube_graph` we have just created above.\n", "\n", "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", "\n", - "A brief account on theory behind the kernels on the Hypecube space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hypercube.html)." + "A brief account on theory behind the kernels on the Hypecube space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hypercube_graph.html)." ] }, { @@ -150,7 +150,7 @@ "metadata": {}, "outputs": [], "source": [ - "kernel = MaternGeometricKernel(hypercube)" + "kernel = MaternGeometricKernel(hypercube_graph)" ] }, { @@ -248,7 +248,7 @@ "source": [ "key = np.random.RandomState(1234)\n", "\n", - "key, xs = hypercube.random(key, 3)\n", + "key, xs = hypercube_graph.random(key, 3)\n", "\n", "print(xs, xs.dtype)" ] @@ -706,7 +706,7 @@ "source": [ "## Citation\n", "\n", - "If you are using the Hypercube space and GeometricKernels, please consider citing\n", + "If you are using the HypercubeGraph space and GeometricKernels, please consider citing\n", "\n", "```\n", "@article{mostowsky2024,\n", diff --git a/tests/spaces/test_hypercube.py b/tests/spaces/test_hypercube_graph.py similarity index 93% rename from tests/spaces/test_hypercube.py rename to tests/spaces/test_hypercube_graph.py index ef87e839..e45be845 100644 --- a/tests/spaces/test_hypercube.py +++ b/tests/spaces/test_hypercube_graph.py @@ -5,8 +5,8 @@ from plum import Tuple from geometric_kernels.kernels import MaternGeometricKernel -from geometric_kernels.spaces import Hypercube -from geometric_kernels.utils.special_functions import hypercube_heat_kernel +from geometric_kernels.spaces import HypercubeGraph +from geometric_kernels.utils.special_functions import hypercube_graph_heat_kernel from geometric_kernels.utils.utils import ( binary_vectors_and_subsets, chain, @@ -18,13 +18,13 @@ def inputs(request) -> Tuple[B.Numeric]: """ Returns a tuple (space, eigenfunctions, X, X2) where: - - space is a Hypercube object with dimension equal to request.param, + - space is a HypercubeGraph object with dimension equal to request.param, - eigenfunctions is the respective Eigenfunctions object with at most 5 levels, - X is a random sample of random size from the space, - X2 is another random sample of random size from the space. """ d = request.param - space = Hypercube(d) + space = HypercubeGraph(d) eigenfunctions = space.get_eigenfunctions(min(space.dim + 1, 5)) key = np.random.RandomState() @@ -164,7 +164,7 @@ def test_weighted_outerproduct_against_phi_product(inputs, backend): weights = np.random.rand(num_levels, 1) result = B.einsum("id,...nki->...nk", weights, sum_phi_phi_for_level) - # Check that `weighted_outerproduct`, which for the hypercube has a + # Check that `weighted_outerproduct`, which for HypercubeGraph has a # dedicated implementation, returns the same result as the usual way of # computing the `weighted_outerproduct` (based on the `phi_product` method). check_function_with_backend( @@ -182,7 +182,7 @@ def test_weighted_outerproduct_diag_against_phi_product(inputs, backend): weights = np.random.rand(num_levels, 1) result = B.einsum("id,ni->n", weights, phi_product_diag) # [N,] - # Check that `weighted_outerproduct_diag`, which for the hypercube has a + # Check that `weighted_outerproduct_diag`, which for HypercubeGraph has a # dedicated implementation, returns the same result as the usual way of # computing the `weighted_outerproduct_diag` (based on the # `phi_product_diag` method). @@ -196,13 +196,13 @@ def test_weighted_outerproduct_diag_against_phi_product(inputs, backend): def test_against_analytic_heat_kernel(inputs, lengthscale, backend): space, _, X, X2 = inputs lengthscale = np.array([lengthscale]) - result = hypercube_heat_kernel(lengthscale, X, X2) + result = hypercube_graph_heat_kernel(lengthscale, X, X2) kernel = MaternGeometricKernel(space) - # Check that MaternGeometricKernel on the hypercube with nu=infinity + # Check that MaternGeometricKernel on HypercubeGraph with nu=infinity # coincides with the closed form expression for the heat kernel on the - # hypercube. + # hypercube graph. check_function_with_backend( backend, result, diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 86891aae..26fdf186 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -5,9 +5,9 @@ import pytest from sklearn.metrics.pairwise import rbf_kernel -from geometric_kernels.spaces import Hypercube +from geometric_kernels.spaces import HypercubeGraph from geometric_kernels.utils.special_functions import ( - hypercube_heat_kernel, + hypercube_graph_heat_kernel, kravchuk_normalized, walsh_function, ) @@ -117,8 +117,8 @@ def test_kravchuk_precomputed(all_xs_and_combs, backend): @pytest.mark.parametrize("d", [1, 5, 10]) @pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) -def test_hypercube_heat_kernel(d, lengthscale, backend): - space = Hypercube(d) +def test_hypercube_graph_heat_kernel(d, lengthscale, backend): + space = HypercubeGraph(d) key = np.random.RandomState() N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) @@ -128,12 +128,12 @@ def test_hypercube_heat_kernel(d, lengthscale, backend): gamma = -log(tanh(lengthscale**2 / 2)) result = rbf_kernel(X, X2, gamma=gamma) - # Checks that the heat kernel on the hypercube coincides with the RBF kernel + # Checks that the heat kernel on the hypercube graph coincides with the RBF # restricted onto binary vectors, with appropriately redefined length scale. check_function_with_backend( backend, result, - lambda lengthscale, X, X2: hypercube_heat_kernel( + lambda lengthscale, X, X2: hypercube_graph_heat_kernel( lengthscale, X, X2, normalized_laplacian=False ), np.array([lengthscale]), @@ -148,10 +148,10 @@ def test_hypercube_heat_kernel(d, lengthscale, backend): X_second = X[0:1, 3:] X2_second = X2[0:1, 3:] - K_first = hypercube_heat_kernel( + K_first = hypercube_graph_heat_kernel( np.array([lengthscale]), X_first, X2_first, normalized_laplacian=False ) - K_second = hypercube_heat_kernel( + K_second = hypercube_graph_heat_kernel( np.array([lengthscale]), X_second, X2_second, normalized_laplacian=False ) @@ -162,7 +162,7 @@ def test_hypercube_heat_kernel(d, lengthscale, backend): check_function_with_backend( backend, result, - lambda lengthscale, X, X2: hypercube_heat_kernel( + lambda lengthscale, X, X2: hypercube_graph_heat_kernel( lengthscale, X, X2, normalized_laplacian=False ), np.array([lengthscale]), From 1a08413b57cb5ae97d6c821e4eed033adac5cbd4 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 13 Aug 2024 14:33:22 +0200 Subject: [PATCH 16/24] Move the utilty functions for testing from utils/utils.py to tests/helper.py. For imports to work, add __init__.py throughout the tests/ folder hierarchy --- geometric_kernels/utils/utils.py | 112 +------------------------ tests/helper.py | 113 ++++++++++++++++++++++++++ tests/kernels/__init__.py | 0 tests/sampling/__init__.py | 0 tests/spaces/__init__.py | 0 tests/spaces/test_hypercube_graph.py | 8 +- tests/utils/__init__.py | 0 tests/utils/test_special_functions.py | 8 +- tests/utils/test_utils.py | 3 +- 9 files changed, 122 insertions(+), 122 deletions(-) create mode 100644 tests/helper.py create mode 100644 tests/kernels/__init__.py create mode 100644 tests/sampling/__init__.py create mode 100644 tests/spaces/__init__.py create mode 100644 tests/utils/__init__.py diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 7eb1474f..fc0b8d3d 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -11,9 +11,7 @@ import einops import lab as B import numpy as np -from beartype.door import die_if_unbearable, is_bearable -from beartype.typing import Any, Callable, Generator, List, Optional, Set, Tuple, Union -from plum import ModuleType, resolve_type_hint +from beartype.typing import Callable, Generator, List, Set, Tuple from geometric_kernels import resources from geometric_kernels.lab_extras import ( @@ -23,8 +21,6 @@ restore_random_state, ) -EagerTensor = ModuleType("tensorflow.python.framework.ops", "EagerTensor") - def chain(elements: B.Numeric, repetitions: List[int]) -> B.Numeric: """ @@ -360,109 +356,3 @@ def binary_vectors_and_subsets(d: int): i += 1 return x, combs - - -def np_to_backend(value: B.NPNumeric, backend: str): - """ - Converts a numpy array to the desired backend. - - :param value: - A numpy array. - :param backend: - The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". - - :raises ValueError: - If the backend is not recognized. - - :return: - The array `value` converted to the desired backend. - """ - if backend == "tensorflow": - import tensorflow as tf - - return tf.convert_to_tensor(value) - elif backend in ["torch", "pytorch"]: - import torch - - return torch.tensor(value) - elif backend == "numpy": - return value - elif backend == "jax": - import jax.numpy as jnp - - return jnp.array(value) - else: - raise ValueError("Unknown backend: {}".format(backend)) - - -def array_type(backend: str): - """ - Returns the array type corresponding to the given backend. - - :param backend: - The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". - - :return: - The array type corresponding to the given backend. - """ - if backend == "tensorflow": - return resolve_type_hint(Union[B.TFNumeric, EagerTensor]) - elif backend in ["torch", "pytorch"]: - return resolve_type_hint(B.TorchNumeric) - elif backend == "numpy": - return resolve_type_hint(B.NPNumeric) - elif backend == "jax": - return resolve_type_hint(B.JAXNumeric) - else: - raise ValueError("Unknown backend: {}".format(backend)) - - -def check_function_with_backend( - backend: str, - result: Any, - f: Callable, - *args: Any, - compare_to_result: Optional[Callable] = None, - atol=1e-4, -): - """ - 1. Casts the arguments `*args` to the backend `backend`. - 2. Runs the function `f` on the casted arguments. - 3. Checks that the result is of the backend `backend`. - 4. If no `compare_to_result` kwarg is provided, checks that the result, - casted back to numpy backend, coincides with the given `result`. - If `compare_to_result` is provided, checks if - `compare_to_result(result, f_output)` is True. - - :param backend: - The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". - :param result: - The expected result of the function, if no `compare_to_result` kwarg is - provided, expected to be a numpy array. Otherwise, can be anything. - :param f: - The backend-independent function to run. - :param args: - The arguments to pass to the function `f`, expected to be numpy arrays - or non-array arguments. - :param compare_to_result: - A function that takes two arguments, the computed result and the - expected result, and returns a boolean. - :param atol: - The absolute tolerance to use when comparing the computed result with - the expected result. - """ - - args_casted = [] - for arg in args: - if is_bearable(arg, B.Numeric): - # We only expect numpy arrays here - die_if_unbearable(arg, B.NPNumeric) - args_casted.append(np_to_backend(arg, backend)) - else: - args_casted.append(arg) - f_output = f(*args_casted) - assert is_bearable(f_output, array_type(backend)) - if compare_to_result is None: - np.testing.assert_allclose(B.to_numpy(f_output), result, atol=atol) - else: - assert compare_to_result(result, f_output) diff --git a/tests/helper.py b/tests/helper.py new file mode 100644 index 00000000..3dad2210 --- /dev/null +++ b/tests/helper.py @@ -0,0 +1,113 @@ +import lab as B +import numpy as np +from beartype.door import die_if_unbearable, is_bearable +from beartype.typing import Any, Callable, Optional, Union +from plum import ModuleType, resolve_type_hint + +EagerTensor = ModuleType("tensorflow.python.framework.ops", "EagerTensor") + + +def np_to_backend(value: B.NPNumeric, backend: str): + """ + Converts a numpy array to the desired backend. + + :param value: + A numpy array. + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + + :raises ValueError: + If the backend is not recognized. + + :return: + The array `value` converted to the desired backend. + """ + if backend == "tensorflow": + import tensorflow as tf + + return tf.convert_to_tensor(value) + elif backend in ["torch", "pytorch"]: + import torch + + return torch.tensor(value) + elif backend == "numpy": + return value + elif backend == "jax": + import jax.numpy as jnp + + return jnp.array(value) + else: + raise ValueError("Unknown backend: {}".format(backend)) + + +def array_type(backend: str): + """ + Returns the array type corresponding to the given backend. + + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + + :return: + The array type corresponding to the given backend. + """ + if backend == "tensorflow": + return resolve_type_hint(Union[B.TFNumeric, EagerTensor]) + elif backend in ["torch", "pytorch"]: + return resolve_type_hint(B.TorchNumeric) + elif backend == "numpy": + return resolve_type_hint(B.NPNumeric) + elif backend == "jax": + return resolve_type_hint(B.JAXNumeric) + else: + raise ValueError(f"Unknown backend: {backend}") + + +def check_function_with_backend( + backend: str, + result: Any, + f: Callable, + *args: Any, + compare_to_result: Optional[Callable] = None, + atol=1e-4, +): + """ + 1. Casts the arguments `*args` to the backend `backend`. + 2. Runs the function `f` on the casted arguments. + 3. Checks that the result is of the backend `backend`. + 4. If no `compare_to_result` kwarg is provided, checks that the result, + casted back to numpy backend, coincides with the given `result`. + If `compare_to_result` is provided, checks if + `compare_to_result(result, f_output)` is True. + + :param backend: + The backend to use, one of the strings "tensorflow", "torch", "numpy", "jax". + :param result: + The expected result of the function, if no `compare_to_result` kwarg is + provided, expected to be a numpy array. Otherwise, can be anything. + :param f: + The backend-independent function to run. + :param args: + The arguments to pass to the function `f`, expected to be numpy arrays + or non-array arguments. + :param compare_to_result: + A function that takes two arguments, the computed result and the + expected result, and returns a boolean. + :param atol: + The absolute tolerance to use when comparing the computed result with + the expected result. + """ + + args_casted = [] + for arg in args: + if is_bearable(arg, B.Numeric): + # We only expect numpy arrays here + die_if_unbearable(arg, B.NPNumeric) + args_casted.append(np_to_backend(arg, backend)) + else: + args_casted.append(arg) + f_output = f(*args_casted) + assert is_bearable(f_output, array_type(backend)) + if compare_to_result is None: + np.testing.assert_allclose(B.to_numpy(f_output), result, atol=atol) + else: + assert compare_to_result(result, f_output) diff --git a/tests/kernels/__init__.py b/tests/kernels/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/sampling/__init__.py b/tests/sampling/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/spaces/__init__.py b/tests/spaces/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/spaces/test_hypercube_graph.py b/tests/spaces/test_hypercube_graph.py index e45be845..40e2a7a3 100644 --- a/tests/spaces/test_hypercube_graph.py +++ b/tests/spaces/test_hypercube_graph.py @@ -7,11 +7,9 @@ from geometric_kernels.kernels import MaternGeometricKernel from geometric_kernels.spaces import HypercubeGraph from geometric_kernels.utils.special_functions import hypercube_graph_heat_kernel -from geometric_kernels.utils.utils import ( - binary_vectors_and_subsets, - chain, - check_function_with_backend, -) +from geometric_kernels.utils.utils import binary_vectors_and_subsets, chain + +from ..helper import check_function_with_backend @pytest.fixture(params=[1, 2, 3, 5, 10]) diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 26fdf186..02ccba7c 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -11,11 +11,9 @@ kravchuk_normalized, walsh_function, ) -from geometric_kernels.utils.utils import ( - binary_vectors_and_subsets, - check_function_with_backend, - hamming_distance, -) +from geometric_kernels.utils.utils import binary_vectors_and_subsets, hamming_distance + +from ..helper import check_function_with_backend @pytest.fixture(params=[1, 2, 3, 5, 10]) diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py index cf1dc376..0bef5260 100644 --- a/tests/utils/test_utils.py +++ b/tests/utils/test_utils.py @@ -3,11 +3,12 @@ from geometric_kernels.utils.utils import ( binary_vectors_and_subsets, - check_function_with_backend, hamming_distance, log_binomial, ) +from ..helper import check_function_with_backend + @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) def test_hamming_distance(backend): From 90824a22a97046be0a03cf9931286c83a80f54d0 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 13 Aug 2024 16:48:12 +0200 Subject: [PATCH 17/24] Remove unnecessary lambda in tests/spaces/test_hypercube_graph.py --- tests/spaces/test_hypercube_graph.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/spaces/test_hypercube_graph.py b/tests/spaces/test_hypercube_graph.py index 40e2a7a3..8b5d6389 100644 --- a/tests/spaces/test_hypercube_graph.py +++ b/tests/spaces/test_hypercube_graph.py @@ -41,7 +41,7 @@ def test_call_eigenfunctions(inputs: Tuple[B.NPNumeric, B.NPNumeric], backend): check_function_with_backend( backend, (X.shape[0], eigenfunctions.num_eigenfunctions), - lambda X: eigenfunctions(X), + eigenfunctions, X, compare_to_result=lambda res, f_out: f_out.shape == res, ) From 9dc33e34298d43e68c5f4ecb8f50c011bef76c0d Mon Sep 17 00:00:00 2001 From: imbirik <32593555+imbirik@users.noreply.github.com> Date: Sat, 21 Sep 2024 16:45:29 +0100 Subject: [PATCH 18/24] initial commit add _compute_keys_sorting_sgn function, resolving float numbers comparision problems. --- geometric_kernels/spaces/so.py | 12 ++++++++++-- geometric_kernels/spaces/su.py | 15 +++++++++++++-- 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/geometric_kernels/spaces/so.py b/geometric_kernels/spaces/so.py index 779d275a..85794c4e 100644 --- a/geometric_kernels/spaces/so.py +++ b/geometric_kernels/spaces/so.py @@ -63,11 +63,19 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: signature[-1] = -signature[-1] signatures.append(tuple(signature)) - eigenvalues = [self._compute_eigenvalue(signature) for signature in signatures] - min_ind = np.argsort(eigenvalues)[:num_levels] + keys = [self._compute_keys_sorting_sgn(signature) for signature in signatures] + min_ind = np.argsort(keys)[:num_levels] signatures = [signatures[i] for i in min_ind] return signatures + def _compute_keys_sorting_sgn(self, signature): + np_sgn = 2*np.array(signature, dtype=np.int64) + rho = 2 * np.arange(self.rank - 1, -1, -1) + if self.n % 2 != 0: + rho = rho + 1 + eigenvalue = np.sum((rho + np_sgn) ** 2) - np.sum(rho ** 2) + return (eigenvalue, signature) + def _compute_dimension(self, signature: Tuple[int, ...]) -> int: if self.n % 2 == 1: qs = [pk + self.rank - k - 1 / 2 for k, pk in enumerate(signature)] diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index a6c89d23..9da17c47 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -48,8 +48,8 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: ) signatures = [sgn + (0,) for sgn in signatures] - eigenvalues = [self._compute_eigenvalue(signature) for signature in signatures] - min_ind = np.argsort(eigenvalues)[:num_levels] + keys = [self._compute_keys_sorting_sgn(signature) for signature in signatures] + min_ind = np.argsort(keys)[:num_levels] signatures = [signatures[i] for i in min_ind] return signatures @@ -70,6 +70,17 @@ def _compute_dimension(self, signature: Tuple[int, ...]) -> int: ) return int(round(rep_dim)) + def _compute_keys_sorting_sgn(self, signature): + normalized_signature = 2*len(signature) * np.asarray(signature, dtype=np.int64) - 2*np.sum( + signature + ) + norm_rho = len(signature) * np.arange(self.n - 1, -self.n, -2) + lb_eigenvalue = ( + np.sum((norm_rho + normalized_signature) ** 2) + - np.sum(norm_rho** 2) + ) + return (lb_eigenvalue, signature) + def _compute_eigenvalue(self, signature: Tuple[int, ...]) -> B.Float: normalized_signature = np.asarray(signature, dtype=np.float64) - np.mean( signature From 015194ab2240a88e95ca7972db1d46bd232c9d5e Mon Sep 17 00:00:00 2001 From: imbirik <32593555+imbirik@users.noreply.github.com> Date: Mon, 23 Sep 2024 01:22:41 +0100 Subject: [PATCH 19/24] simplifed approach --- geometric_kernels/spaces/so.py | 16 +++++----------- geometric_kernels/spaces/su.py | 23 ++++++++--------------- 2 files changed, 13 insertions(+), 26 deletions(-) diff --git a/geometric_kernels/spaces/so.py b/geometric_kernels/spaces/so.py index 85794c4e..1ddb8a64 100644 --- a/geometric_kernels/spaces/so.py +++ b/geometric_kernels/spaces/so.py @@ -63,19 +63,13 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: signature[-1] = -signature[-1] signatures.append(tuple(signature)) - keys = [self._compute_keys_sorting_sgn(signature) for signature in signatures] - min_ind = np.argsort(keys)[:num_levels] - signatures = [signatures[i] for i in min_ind] + eig_and_signature = [ + (round(4*self._compute_eigenvalue(signature)), signature) + for signature in signatures] + eig_and_signature.sort() + signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] return signatures - def _compute_keys_sorting_sgn(self, signature): - np_sgn = 2*np.array(signature, dtype=np.int64) - rho = 2 * np.arange(self.rank - 1, -1, -1) - if self.n % 2 != 0: - rho = rho + 1 - eigenvalue = np.sum((rho + np_sgn) ** 2) - np.sum(rho ** 2) - return (eigenvalue, signature) - def _compute_dimension(self, signature: Tuple[int, ...]) -> int: if self.n % 2 == 1: qs = [pk + self.rank - k - 1 / 2 for k, pk in enumerate(signature)] diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index 9da17c47..21dc4ef9 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -47,10 +47,14 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: ) ) signatures = [sgn + (0,) for sgn in signatures] - - keys = [self._compute_keys_sorting_sgn(signature) for signature in signatures] - min_ind = np.argsort(keys)[:num_levels] - signatures = [signatures[i] for i in min_ind] + + eig_and_signature = [ + (round(4 * (len(signature)**2) + * self._compute_eigenvalue(signature)), signature) + for signature in signatures] + + eig_and_signature.sort() + signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] return signatures def _compute_dimension(self, signature: Tuple[int, ...]) -> int: @@ -70,17 +74,6 @@ def _compute_dimension(self, signature: Tuple[int, ...]) -> int: ) return int(round(rep_dim)) - def _compute_keys_sorting_sgn(self, signature): - normalized_signature = 2*len(signature) * np.asarray(signature, dtype=np.int64) - 2*np.sum( - signature - ) - norm_rho = len(signature) * np.arange(self.n - 1, -self.n, -2) - lb_eigenvalue = ( - np.sum((norm_rho + normalized_signature) ** 2) - - np.sum(norm_rho** 2) - ) - return (lb_eigenvalue, signature) - def _compute_eigenvalue(self, signature: Tuple[int, ...]) -> B.Float: normalized_signature = np.asarray(signature, dtype=np.float64) - np.mean( signature From 5b8501760dedec7664232bccf914d3cf184acf11 Mon Sep 17 00:00:00 2001 From: imbirik Date: Sat, 12 Oct 2024 18:03:44 +0100 Subject: [PATCH 20/24] fix of linting modified: geometric_kernels/resources/precomputed_characters.json modified: geometric_kernels/spaces/so.py modified: geometric_kernels/spaces/su.py modified: geometric_kernels/utils/compute_characters.py --- .../resources/precomputed_characters.json | 154 ++++++++++++++---- geometric_kernels/spaces/so.py | 2 +- geometric_kernels/spaces/su.py | 8 +- geometric_kernels/utils/compute_characters.py | 5 +- 4 files changed, 133 insertions(+), 36 deletions(-) diff --git a/geometric_kernels/resources/precomputed_characters.json b/geometric_kernels/resources/precomputed_characters.json index 4fc3fe7e..62ec78e8 100644 --- a/geometric_kernels/resources/precomputed_characters.json +++ b/geometric_kernels/resources/precomputed_characters.json @@ -13,6 +13,11 @@ "(18,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], "(19,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], "(2,)": [[1,1,1,1,1],[[2,0],[1,0],[0,2],[0,1],[0,0]]], + "(20,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[20,0],[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,20],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], + "(21,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[21,0],[20,0],[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,21],[0,20],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], + "(22,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[22,0],[21,0],[20,0],[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,22],[0,21],[0,20],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], + "(23,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[23,0],[22,0],[21,0],[20,0],[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,23],[0,22],[0,21],[0,20],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], + "(24,)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[24,0],[23,0],[22,0],[21,0],[20,0],[19,0],[18,0],[17,0],[16,0],[15,0],[14,0],[13,0],[12,0],[11,0],[10,0],[9,0],[8,0],[7,0],[6,0],[5,0],[4,0],[3,0],[2,0],[1,0],[0,24],[0,23],[0,22],[0,21],[0,20],[0,19],[0,18],[0,17],[0,16],[0,15],[0,14],[0,13],[0,12],[0,11],[0,10],[0,9],[0,8],[0,7],[0,6],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], "(3,)": [[1,1,1,1,1,1,1],[[3,0],[2,0],[1,0],[0,3],[0,2],[0,1],[0,0]]], "(4,)": [[1,1,1,1,1,1,1,1,1],[[4,0],[3,0],[2,0],[1,0],[0,4],[0,3],[0,2],[0,1],[0,0]]], "(5,)": [[1,1,1,1,1,1,1,1,1,1,1],[[5,0],[4,0],[3,0],[2,0],[1,0],[0,5],[0,4],[0,3],[0,2],[0,1],[0,0]]], @@ -39,9 +44,14 @@ "(3, 2)": [[1,1,1,1,1,1,1,1,1,1,1,1],[[3,2,0,0],[2,3,0,0],[2,1,0,0],[1,2,0,0],[1,0,0,0],[0,1,0,0],[0,0,3,2],[0,0,2,3],[0,0,2,1],[0,0,1,2],[0,0,1,0],[0,0,0,1]]], "(3, 3)": [[1,1,1,1,1,1,1],[[3,3,0,0],[2,2,0,0],[1,1,0,0],[0,0,3,3],[0,0,2,2],[0,0,1,1],[0,0,0,0]]], "(4, -1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,0,0,1],[3,0,0,2],[3,0,0,0],[2,1,0,0],[2,0,0,3],[2,0,0,1],[1,2,0,0],[1,0,0,4],[1,0,0,2],[1,0,0,0],[0,4,1,0],[0,3,2,0],[0,3,0,0],[0,2,3,0],[0,2,1,0],[0,1,4,0],[0,1,2,0],[0,1,0,0],[0,0,3,0],[0,0,2,1],[0,0,1,2],[0,0,1,0],[0,0,0,3],[0,0,0,1]]], + "(4, -2)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,0,0,2],[3,0,0,3],[3,0,0,1],[2,0,0,4],[2,0,0,2],[2,0,0,0],[1,1,0,0],[1,0,0,3],[1,0,0,1],[0,4,2,0],[0,3,3,0],[0,3,1,0],[0,2,4,0],[0,2,2,0],[0,2,0,0],[0,1,3,0],[0,1,1,0],[0,0,2,0],[0,0,1,1],[0,0,0,2],[0,0,0,0]]], + "(4, -3)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,0,0,3],[3,0,0,4],[3,0,0,2],[2,0,0,3],[2,0,0,1],[1,0,0,2],[1,0,0,0],[0,4,3,0],[0,3,4,0],[0,3,2,0],[0,2,3,0],[0,2,1,0],[0,1,2,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]], "(4, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,0,0,0],[3,1,0,0],[3,0,0,1],[2,2,0,0],[2,0,0,2],[2,0,0,0],[1,3,0,0],[1,1,0,0],[1,0,0,3],[1,0,0,1],[0,4,0,0],[0,3,1,0],[0,2,2,0],[0,2,0,0],[0,1,3,0],[0,1,1,0],[0,0,4,0],[0,0,3,1],[0,0,2,2],[0,0,2,0],[0,0,1,3],[0,0,1,1],[0,0,0,4],[0,0,0,2],[0,0,0,0]]], "(4, 1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,1,0,0],[3,2,0,0],[3,0,0,0],[2,3,0,0],[2,1,0,0],[2,0,0,1],[1,4,0,0],[1,2,0,0],[1,0,0,2],[1,0,0,0],[0,3,0,0],[0,2,1,0],[0,1,2,0],[0,1,0,0],[0,0,4,1],[0,0,3,2],[0,0,3,0],[0,0,2,3],[0,0,2,1],[0,0,1,4],[0,0,1,2],[0,0,1,0],[0,0,0,3],[0,0,0,1]]], - "(4, 2)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,2,0,0],[3,3,0,0],[3,1,0,0],[2,4,0,0],[2,2,0,0],[2,0,0,0],[1,3,0,0],[1,1,0,0],[1,0,0,1],[0,2,0,0],[0,1,1,0],[0,0,4,2],[0,0,3,3],[0,0,3,1],[0,0,2,4],[0,0,2,2],[0,0,2,0],[0,0,1,3],[0,0,1,1],[0,0,0,2],[0,0,0,0]]] + "(4, 2)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,2,0,0],[3,3,0,0],[3,1,0,0],[2,4,0,0],[2,2,0,0],[2,0,0,0],[1,3,0,0],[1,1,0,0],[1,0,0,1],[0,2,0,0],[0,1,1,0],[0,0,4,2],[0,0,3,3],[0,0,3,1],[0,0,2,4],[0,0,2,2],[0,0,2,0],[0,0,1,3],[0,0,1,1],[0,0,0,2],[0,0,0,0]]], + "(4, 3)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,3,0,0],[3,4,0,0],[3,2,0,0],[2,3,0,0],[2,1,0,0],[1,2,0,0],[1,0,0,0],[0,1,0,0],[0,0,4,3],[0,0,3,4],[0,0,3,2],[0,0,2,3],[0,0,2,1],[0,0,1,2],[0,0,1,0],[0,0,0,1]]], + "(5, -1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[5,0,0,1],[4,0,0,2],[4,0,0,0],[3,1,0,0],[3,0,0,3],[3,0,0,1],[2,2,0,0],[2,0,0,4],[2,0,0,2],[2,0,0,0],[1,3,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,3],[1,0,0,1],[0,5,1,0],[0,4,2,0],[0,4,0,0],[0,3,3,0],[0,3,1,0],[0,2,4,0],[0,2,2,0],[0,2,0,0],[0,1,5,0],[0,1,3,0],[0,1,1,0],[0,0,4,0],[0,0,3,1],[0,0,2,2],[0,0,2,0],[0,0,1,3],[0,0,1,1],[0,0,0,4],[0,0,0,2],[0,0,0,0]]], + "(5, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[5,0,0,0],[4,1,0,0],[4,0,0,1],[3,2,0,0],[3,0,0,2],[3,0,0,0],[2,3,0,0],[2,1,0,0],[2,0,0,3],[2,0,0,1],[1,4,0,0],[1,2,0,0],[1,0,0,4],[1,0,0,2],[1,0,0,0],[0,5,0,0],[0,4,1,0],[0,3,2,0],[0,3,0,0],[0,2,3,0],[0,2,1,0],[0,1,4,0],[0,1,2,0],[0,1,0,0],[0,0,5,0],[0,0,4,1],[0,0,3,2],[0,0,3,0],[0,0,2,3],[0,0,2,1],[0,0,1,4],[0,0,1,2],[0,0,1,0],[0,0,0,5],[0,0,0,3],[0,0,0,1]]] }, "SO(5)": { "(0, 0)": [[1],[[0,0,0,0]]], @@ -63,7 +73,12 @@ "(5, 1)": [[1,1,1,1,2,1,2,3,1,2,4,1,2,4,4,1,2,4,5,1,2,4,5,6,1,2,4,5,7,1,2,4,5,7,7,1,1,1,2,3,1,2,4,4,1,2,4,5,6,1,2,4,5,7,7,1,1,1,2,3,1,2,4,4,1,2,4,5,6,1,2,4,5,7,7,1,3,4,6,7,8],[[5,1,0,0],[5,0,0,1],[5,0,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,5,1,0],[0,5,0,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,5,1],[0,0,5,0],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], "(5, 2)": [[1,1,1,1,1,1,2,3,1,2,3,3,1,2,4,5,1,2,4,5,6,1,2,4,6,8,1,2,4,6,8,8,1,3,5,8,9,1,3,5,8,9,10,1,1,1,1,2,3,3,1,2,4,5,6,1,2,4,6,8,8,1,3,5,8,9,10,1,1,1,1,2,3,3,1,2,4,5,6,1,2,4,6,8,8,1,3,5,8,9,10,1,3,6,8,10,10],[[5,2,0,0],[5,1,0,0],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], "(5, 3)": [[1,1,1,1,1,1,1,1,2,3,3,1,2,3,3,3,1,2,4,5,6,1,2,4,5,6,6,1,3,5,7,8,1,3,5,7,8,9,1,3,6,8,10,1,3,6,8,10,10,1,1,1,1,1,2,3,3,3,1,2,4,5,6,6,1,3,5,7,8,9,1,3,6,8,10,10,1,1,1,1,1,2,3,3,3,1,2,4,5,6,6,1,3,5,7,8,9,1,3,6,8,10,10,1,3,6,9,10,11],[[5,3,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,3],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,4,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,4],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,5,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,5],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,5,3,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,4,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,5,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,5,3],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,4],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,5],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], - "(6, 0)": [[1,1,1,1,1,1,1,1,2,1,1,2,1,1,2,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,1,1,2,2,3,3,1,1,1,1,1,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,3,1,1,1,1,1,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,3,1,1,2,2,3,3,4],[[6,0,0,0],[5,1,0,0],[5,0,0,1],[5,0,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,6,0,0],[0,5,1,0],[0,5,0,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,6,0],[0,0,5,1],[0,0,5,0],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,6],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]] + "(5, 4)": [[1,1,1,1,1,1,1,1,1,1,2,3,3,3,1,2,3,3,3,3,1,3,4,5,5,1,3,4,5,5,5,1,3,5,6,7,1,3,5,6,7,7,1,3,5,7,8,1,3,5,7,8,9,1,1,1,1,1,1,2,3,3,3,3,1,3,4,5,5,5,1,3,5,6,7,7,1,3,5,7,8,9,1,1,1,1,1,1,2,3,3,3,3,1,3,4,5,5,5,1,3,5,6,7,7,1,3,5,7,8,9,1,3,5,7,9,9],[[5,4,0,0],[5,3,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,4],[5,0,0,3],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,5,0,0],[4,4,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,5],[4,0,0,4],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,5,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,5],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,5,4,0],[0,5,3,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,5,0],[0,4,4,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,5,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,5,4],[0,0,5,3],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,5],[0,0,4,4],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,5],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], + "(5, 5)": [[1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,2,2,1,2,3,3,3,1,2,3,3,3,3,1,2,3,4,4,1,2,3,4,4,4,1,2,3,4,5,1,2,3,4,5,5,1,1,1,1,1,1,1,2,2,2,2,2,1,2,3,3,3,3,1,2,3,4,4,4,1,2,3,4,5,5,1,1,1,1,1,1,1,2,2,2,2,2,1,2,3,3,3,3,1,2,3,4,4,4,1,2,3,4,5,5,1,2,3,4,5,6],[[5,5,0,0],[5,4,0,0],[5,3,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,5],[5,0,0,4],[5,0,0,3],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,5,0,0],[4,4,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,5],[4,0,0,4],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,5,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,5],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,5,5,0],[0,5,4,0],[0,5,3,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,5,0],[0,4,4,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,5,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,5,5],[0,0,5,4],[0,0,5,3],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,5],[0,0,4,4],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,5],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], + "(6, 0)": [[1,1,1,1,1,1,1,1,2,1,1,2,1,1,2,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,1,1,2,2,3,3,1,1,1,1,1,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,3,1,1,1,1,1,2,1,1,2,2,1,1,2,2,3,1,1,2,2,3,3,1,1,2,2,3,3,4],[[6,0,0,0],[5,1,0,0],[5,0,0,1],[5,0,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,6,0,0],[0,5,1,0],[0,5,0,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,6,0],[0,0,5,1],[0,0,5,0],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,6],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], + "(6, 1)": [[1,1,1,1,2,1,2,3,1,2,4,1,2,4,4,1,2,4,5,1,2,4,5,6,1,2,4,5,7,1,2,4,5,7,7,1,2,4,5,7,8,1,2,4,5,7,8,9,1,1,1,2,3,1,2,4,4,1,2,4,5,6,1,2,4,5,7,7,1,2,4,5,7,8,9,1,1,1,2,3,1,2,4,4,1,2,4,5,6,1,2,4,5,7,7,1,2,4,5,7,8,9,1,3,4,6,7,9,9],[[6,1,0,0],[6,0,0,1],[6,0,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,6,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,6],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,6,1,0],[0,6,0,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,6,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,6,1],[0,0,6,0],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,6],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,6],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], + "(6, 2)": [[1,1,1,1,1,1,2,3,1,2,3,3,1,2,4,5,1,2,4,5,6,1,2,4,6,8,1,2,4,6,8,8,1,2,4,6,9,10,1,2,4,6,9,10,11,1,3,5,8,10,12,1,3,5,8,10,12,12,1,1,1,1,2,3,3,1,2,4,5,6,1,2,4,6,8,8,1,2,4,6,9,10,11,1,3,5,8,10,12,12,1,1,1,1,2,3,3,1,2,4,5,6,1,2,4,6,8,8,1,2,4,6,9,10,11,1,3,5,8,10,12,12,1,3,6,8,11,12,13],[[6,2,0,0],[6,1,0,0],[6,0,0,2],[6,0,0,1],[6,0,0,0],[5,3,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,3],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,4,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,4],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,5,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,5],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,6,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,6],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,6,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,6],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,6,2,0],[0,6,1,0],[0,6,0,0],[0,5,3,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,4,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,5,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,6,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,6,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,6,2],[0,0,6,1],[0,0,6,0],[0,0,5,3],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,4],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,5],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,6],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,6],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,6],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]], + "(6, 3)": [[1,1,1,1,1,1,1,1,2,3,3,1,2,3,3,3,1,2,4,5,6,1,2,4,5,6,6,1,2,4,6,8,9,1,2,4,6,8,9,10,1,3,5,8,10,12,1,3,5,8,10,12,12,1,3,6,9,12,13,1,3,6,9,12,13,14,1,1,1,1,1,2,3,3,3,1,2,4,5,6,6,1,2,4,6,8,9,10,1,3,5,8,10,12,12,1,3,6,9,12,13,14,1,1,1,1,1,2,3,3,3,1,2,4,5,6,6,1,2,4,6,8,9,10,1,3,5,8,10,12,12,1,3,6,9,12,13,14,1,3,6,10,12,14,14],[[6,3,0,0],[6,2,0,0],[6,1,0,0],[6,0,0,3],[6,0,0,2],[6,0,0,1],[6,0,0,0],[5,4,0,0],[5,3,0,0],[5,2,0,0],[5,1,0,0],[5,0,0,4],[5,0,0,3],[5,0,0,2],[5,0,0,1],[5,0,0,0],[4,5,0,0],[4,4,0,0],[4,3,0,0],[4,2,0,0],[4,1,0,0],[4,0,0,5],[4,0,0,4],[4,0,0,3],[4,0,0,2],[4,0,0,1],[4,0,0,0],[3,6,0,0],[3,5,0,0],[3,4,0,0],[3,3,0,0],[3,2,0,0],[3,1,0,0],[3,0,0,6],[3,0,0,5],[3,0,0,4],[3,0,0,3],[3,0,0,2],[3,0,0,1],[3,0,0,0],[2,6,0,0],[2,5,0,0],[2,4,0,0],[2,3,0,0],[2,2,0,0],[2,1,0,0],[2,0,0,6],[2,0,0,5],[2,0,0,4],[2,0,0,3],[2,0,0,2],[2,0,0,1],[2,0,0,0],[1,6,0,0],[1,5,0,0],[1,4,0,0],[1,3,0,0],[1,2,0,0],[1,1,0,0],[1,0,0,6],[1,0,0,5],[1,0,0,4],[1,0,0,3],[1,0,0,2],[1,0,0,1],[1,0,0,0],[0,6,3,0],[0,6,2,0],[0,6,1,0],[0,6,0,0],[0,5,4,0],[0,5,3,0],[0,5,2,0],[0,5,1,0],[0,5,0,0],[0,4,5,0],[0,4,4,0],[0,4,3,0],[0,4,2,0],[0,4,1,0],[0,4,0,0],[0,3,6,0],[0,3,5,0],[0,3,4,0],[0,3,3,0],[0,3,2,0],[0,3,1,0],[0,3,0,0],[0,2,6,0],[0,2,5,0],[0,2,4,0],[0,2,3,0],[0,2,2,0],[0,2,1,0],[0,2,0,0],[0,1,6,0],[0,1,5,0],[0,1,4,0],[0,1,3,0],[0,1,2,0],[0,1,1,0],[0,1,0,0],[0,0,6,3],[0,0,6,2],[0,0,6,1],[0,0,6,0],[0,0,5,4],[0,0,5,3],[0,0,5,2],[0,0,5,1],[0,0,5,0],[0,0,4,5],[0,0,4,4],[0,0,4,3],[0,0,4,2],[0,0,4,1],[0,0,4,0],[0,0,3,6],[0,0,3,5],[0,0,3,4],[0,0,3,3],[0,0,3,2],[0,0,3,1],[0,0,3,0],[0,0,2,6],[0,0,2,5],[0,0,2,4],[0,0,2,3],[0,0,2,2],[0,0,2,1],[0,0,2,0],[0,0,1,6],[0,0,1,5],[0,0,1,4],[0,0,1,3],[0,0,1,2],[0,0,1,1],[0,0,1,0],[0,0,0,6],[0,0,0,5],[0,0,0,4],[0,0,0,3],[0,0,0,2],[0,0,0,1],[0,0,0,0]]] }, "SO(6)": { "(0, 0, 0)": [[1],[[0,0,0,0,0,0]]], @@ -84,8 +99,13 @@ "(3, 1, -1)": [[1,1,1,1,1,2,1,1,2,2,2,1,1,2,3,1,3,1,1,2,1,3,2,3,2,4,1,1,1,1,2,2,2,1,1,2,1,3,2,3,2,4,1,2,2,2,3,2,4,1,1,1,1,2,2,1,1,2,1,3,2,4,1,2,2,4,1,4],[[3,1,0,0,0,1],[3,0,1,0,1,0],[3,0,0,0,0,0],[2,2,0,0,0,1],[2,1,0,0,0,2],[2,1,0,0,0,0],[2,0,2,0,1,0],[2,0,1,0,2,0],[2,0,1,0,0,0],[2,0,0,0,1,0],[2,0,0,0,0,1],[1,3,0,0,0,1],[1,2,0,0,0,2],[1,2,0,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,1],[1,0,3,0,1,0],[1,0,2,0,2,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,1,0],[1,0,0,0,2,0],[1,0,0,0,1,1],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,3,1,1,0,0],[0,3,0,0,0,0],[0,2,2,1,0,0],[0,2,1,2,0,0],[0,2,1,0,0,0],[0,2,0,1,0,0],[0,2,0,0,0,1],[0,1,3,1,0,0],[0,1,2,2,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,1,0,0],[0,1,0,2,0,0],[0,1,0,1,0,1],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,3,0,0,0],[0,0,2,1,0,0],[0,0,2,0,1,0],[0,0,1,2,0,0],[0,0,1,1,1,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,3,1,1],[0,0,0,3,0,0],[0,0,0,2,2,1],[0,0,0,2,1,2],[0,0,0,2,1,0],[0,0,0,2,0,1],[0,0,0,1,3,1],[0,0,0,1,2,2],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,3,0],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]], "(3, 1, 0)": [[1,1,1,1,1,2,2,1,2,1,2,1,4,1,2,2,2,2,5,1,2,2,5,1,2,2,5,1,5,1,1,1,1,2,1,2,1,4,1,2,2,5,1,2,2,5,1,5,1,1,1,2,1,4,1,2,2,5,1,5,1,1,1,2,1,4,1,2,2,5,1,5,1,1,4,1,5,4,7],[[3,1,0,0,0,0],[3,0,1,0,0,0],[3,0,0,0,1,0],[3,0,0,0,0,1],[2,2,0,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,1],[2,0,2,0,0,0],[2,0,1,0,1,0],[2,0,0,0,2,0],[2,0,0,0,1,1],[2,0,0,0,0,2],[2,0,0,0,0,0],[1,3,0,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,0],[1,0,3,0,0,0],[1,0,2,0,1,0],[1,0,1,0,2,0],[1,0,1,0,0,0],[1,0,0,0,3,0],[1,0,0,0,2,1],[1,0,0,0,1,2],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,1],[0,3,1,0,0,0],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,0,2,0,0],[0,2,0,1,0,1],[0,2,0,0,0,2],[0,2,0,0,0,0],[0,1,3,0,0,0],[0,1,2,1,0,0],[0,1,1,2,0,0],[0,1,1,0,0,0],[0,1,0,3,0,0],[0,1,0,2,0,1],[0,1,0,1,0,2],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,1],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,2,2,0,0],[0,0,2,1,1,0],[0,0,2,0,2,0],[0,0,2,0,0,0],[0,0,1,3,0,0],[0,0,1,2,1,0],[0,0,1,1,2,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,1,0],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,2,0,0],[0,0,0,1,3,0],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,1],[0,0,0,0,3,1],[0,0,0,0,2,2],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,1],[0,0,0,0,0,2],[0,0,0,0,0,0]]], "(3, 1, 1)": [[1,1,1,1,1,2,2,1,1,2,2,1,1,2,1,3,3,2,3,1,1,2,1,3,2,4,1,1,2,1,1,2,2,2,3,1,1,2,1,3,2,4,1,1,1,1,2,2,1,1,2,1,3,2,4,1,2,2,2,3,2,4,1,2,2,4,1,4],[[3,1,1,0,0,0],[3,0,0,0,1,1],[3,0,0,0,0,0],[2,2,1,0,0,0],[2,1,2,0,0,0],[2,1,0,0,0,0],[2,0,1,0,0,0],[2,0,0,0,2,1],[2,0,0,0,1,2],[2,0,0,0,1,0],[2,0,0,0,0,1],[1,3,1,0,0,0],[1,2,2,0,0,0],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,1],[1,0,2,0,0,0],[1,0,1,0,1,0],[1,0,0,0,3,1],[1,0,0,0,2,2],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,1],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,3,0,1,0,1],[0,3,0,0,0,0],[0,2,1,0,0,0],[0,2,0,2,0,1],[0,2,0,1,0,2],[0,2,0,1,0,0],[0,2,0,0,0,1],[0,1,2,0,0,0],[0,1,1,1,0,0],[0,1,0,3,0,1],[0,1,0,2,0,2],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,1],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,3,1,1,0],[0,0,3,0,0,0],[0,0,2,2,1,0],[0,0,2,1,2,0],[0,0,2,1,0,0],[0,0,2,0,1,0],[0,0,1,3,1,0],[0,0,1,2,2,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,1,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,3,0,0],[0,0,0,2,1,0],[0,0,0,2,0,1],[0,0,0,1,2,0],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,3,0],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]], + "(3, 2, -1)": [[1,1,1,1,1,1,1,1,1,2,2,2,1,4,1,2,2,1,4,2,2,2,4,1,1,2,1,4,2,4,6,1,1,1,4,4,6,1,2,2,6,1,6,1,1,1,1,1,1,2,2,1,4,2,2,2,4,1,1,1,4,4,6,1,2,2,6,1,6,1,1,2,2,2,4,1,2,2,6,1,6,1,1,1,1,1,2,2,1,4,2,4,1,1,1,4,4,6,1,6,1,2,4,1,6,4,8],[[3,2,0,0,0,1],[3,1,0,0,0,2],[3,1,0,0,0,0],[3,0,2,0,1,0],[3,0,1,0,2,0],[3,0,1,0,0,0],[3,0,0,0,1,0],[3,0,0,0,0,1],[2,3,0,0,0,1],[2,2,0,0,0,2],[2,2,0,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,1],[2,0,3,0,1,0],[2,0,2,0,2,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,1,0],[2,0,0,0,2,0],[2,0,0,0,1,1],[2,0,0,0,0,2],[2,0,0,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,0],[1,0,3,0,2,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,1,0],[1,0,1,0,2,0],[1,0,1,0,0,0],[1,0,0,0,3,0],[1,0,0,0,2,1],[1,0,0,0,1,2],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,1],[0,3,2,1,0,0],[0,3,1,2,0,0],[0,3,1,0,0,0],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,2,3,1,0,0],[0,2,2,2,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,1,0,0],[0,2,0,2,0,0],[0,2,0,1,0,1],[0,2,0,0,0,2],[0,2,0,0,0,0],[0,1,3,2,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,1,0,0],[0,1,1,2,0,0],[0,1,1,0,0,0],[0,1,0,3,0,0],[0,1,0,2,0,1],[0,1,0,1,0,2],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,1],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,2,2,0,0],[0,0,2,1,1,0],[0,0,2,0,2,0],[0,0,2,0,0,0],[0,0,1,3,0,0],[0,0,1,2,1,0],[0,0,1,1,2,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,1,0],[0,0,0,3,2,1],[0,0,0,3,1,2],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,2,3,1],[0,0,0,2,2,2],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,2,0,0],[0,0,0,1,3,2],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,1],[0,0,0,0,3,1],[0,0,0,0,2,2],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,1],[0,0,0,0,0,2],[0,0,0,0,0,0]]], + "(3, 2, -2)": [[1,1,1,1,1,1,1,2,2,2,1,1,2,2,2,2,2,1,2,2,2,1,3,1,2,2,1,3,2,2,2,3,1,1,1,1,1,2,2,2,2,2,1,2,2,1,3,2,2,2,3,1,2,2,2,2,2,3,1,1,1,1,1,2,2,2,2,1,2,2,1,3,2,3,1,2,2,3,1,3],[[3,2,0,0,0,2],[3,1,0,0,0,1],[3,0,2,0,2,0],[3,0,1,0,1,0],[3,0,0,0,0,0],[2,3,0,0,0,2],[2,2,0,0,0,3],[2,2,0,0,0,1],[2,1,0,0,0,2],[2,1,0,0,0,0],[2,0,3,0,2,0],[2,0,2,0,3,0],[2,0,2,0,1,0],[2,0,1,0,2,0],[2,0,1,0,0,0],[2,0,0,0,1,0],[2,0,0,0,0,1],[1,3,0,0,0,1],[1,2,0,0,0,2],[1,2,0,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,1],[1,0,3,0,1,0],[1,0,2,0,2,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,1,0],[1,0,0,0,2,0],[1,0,0,0,1,1],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,3,2,2,0,0],[0,3,1,1,0,0],[0,3,0,0,0,0],[0,2,3,2,0,0],[0,2,2,3,0,0],[0,2,2,1,0,0],[0,2,1,2,0,0],[0,2,1,0,0,0],[0,2,0,1,0,0],[0,2,0,0,0,1],[0,1,3,1,0,0],[0,1,2,2,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,1,0,0],[0,1,0,2,0,0],[0,1,0,1,0,1],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,3,0,0,0],[0,0,2,1,0,0],[0,0,2,0,1,0],[0,0,1,2,0,0],[0,0,1,1,1,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,3,2,2],[0,0,0,3,1,1],[0,0,0,3,0,0],[0,0,0,2,3,2],[0,0,0,2,2,3],[0,0,0,2,2,1],[0,0,0,2,1,2],[0,0,0,2,1,0],[0,0,0,2,0,1],[0,0,0,1,3,1],[0,0,0,1,2,2],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,3,0],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]], "(3, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,2,2,2,2,4,1,2,2,4,1,2,2,4,1,4,1,1,2,2,4,1,6,1,6,1,2,4,1,6,1,2,4,1,6,4,9,1,1,1,1,1,1,1,2,2,4,1,2,2,4,1,4,1,2,4,1,6,1,2,4,1,6,4,9,1,1,1,1,1,2,2,4,1,4,1,2,4,1,6,4,9,1,1,1,1,1,2,2,4,1,4,1,2,4,1,6,4,9,1,1,1,4,4,9,1,9],[[3,2,0,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,1],[3,0,2,0,0,0],[3,0,1,0,1,0],[3,0,0,0,2,0],[3,0,0,0,1,1],[3,0,0,0,0,2],[3,0,0,0,0,0],[2,3,0,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,1],[2,1,2,0,0,0],[2,1,0,0,0,2],[2,1,0,0,0,0],[2,0,3,0,0,0],[2,0,2,0,1,0],[2,0,1,0,2,0],[2,0,1,0,0,0],[2,0,0,0,3,0],[2,0,0,0,2,1],[2,0,0,0,1,2],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,1],[1,3,1,0,0,0],[1,3,0,0,0,1],[1,2,2,0,0,0],[1,2,0,0,0,2],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,1],[1,0,3,0,1,0],[1,0,2,0,2,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,1,0],[1,0,0,0,3,1],[1,0,0,0,2,2],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,1],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,3,2,0,0,0],[0,3,1,1,0,0],[0,3,0,2,0,0],[0,3,0,1,0,1],[0,3,0,0,0,2],[0,3,0,0,0,0],[0,2,3,0,0,0],[0,2,2,1,0,0],[0,2,1,2,0,0],[0,2,1,0,0,0],[0,2,0,3,0,0],[0,2,0,2,0,1],[0,2,0,1,0,2],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,1],[0,1,3,1,0,0],[0,1,2,2,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,1,0,0],[0,1,0,3,0,1],[0,1,0,2,0,2],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,1],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,3,2,0,0],[0,0,3,1,1,0],[0,0,3,0,2,0],[0,0,3,0,0,0],[0,0,2,3,0,0],[0,0,2,2,1,0],[0,0,2,1,2,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,1,0],[0,0,1,3,1,0],[0,0,1,2,2,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,1,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,3,2,0],[0,0,0,3,1,1],[0,0,0,3,0,2],[0,0,0,3,0,0],[0,0,0,2,3,0],[0,0,0,2,2,1],[0,0,0,2,1,2],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,1],[0,0,0,1,3,1],[0,0,0,1,2,2],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,3,2],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]], - "(3, 2, 1)": [[1,1,1,1,1,1,1,1,1,2,2,1,4,2,2,2,1,2,2,1,4,2,4,1,1,1,4,2,4,2,6,1,2,2,6,1,1,1,4,4,6,1,6,1,1,1,1,1,2,2,1,2,2,1,4,2,4,1,2,2,6,1,1,1,4,4,6,1,6,1,1,1,1,1,2,2,1,4,2,4,1,1,1,4,4,6,1,6,1,1,2,2,2,4,1,2,2,6,1,6,1,2,4,1,6,4,8],[[3,2,1,0,0,0],[3,1,2,0,0,0],[3,1,0,0,0,0],[3,0,1,0,0,0],[3,0,0,0,2,1],[3,0,0,0,1,2],[3,0,0,0,1,0],[3,0,0,0,0,1],[2,3,1,0,0,0],[2,2,2,0,0,0],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,1],[2,0,2,0,0,0],[2,0,1,0,1,0],[2,0,0,0,3,1],[2,0,0,0,2,2],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,1],[2,0,0,0,0,2],[2,0,0,0,0,0],[1,3,2,0,0,0],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,0],[1,0,3,0,0,0],[1,0,2,0,1,0],[1,0,1,0,2,0],[1,0,1,0,0,0],[1,0,0,0,3,2],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,1],[1,0,0,0,1,2],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,1],[0,3,1,0,0,0],[0,3,0,2,0,1],[0,3,0,1,0,2],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,0,3,0,1],[0,2,0,2,0,2],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,1],[0,2,0,0,0,2],[0,2,0,0,0,0],[0,1,3,0,0,0],[0,1,2,1,0,0],[0,1,1,2,0,0],[0,1,1,0,0,0],[0,1,0,3,0,2],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,1],[0,1,0,1,0,2],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,1],[0,0,3,2,1,0],[0,0,3,1,2,0],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,2,3,1,0],[0,0,2,2,2,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,1,0],[0,0,2,0,2,0],[0,0,2,0,0,0],[0,0,1,3,2,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,1,0],[0,0,1,1,2,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,1,0],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,2,0,0],[0,0,0,1,3,0],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,1],[0,0,0,0,3,1],[0,0,0,0,2,2],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,1],[0,0,0,0,0,2],[0,0,0,0,0,0]]] + "(3, 2, 1)": [[1,1,1,1,1,1,1,1,1,2,2,1,4,2,2,2,1,2,2,1,4,2,4,1,1,1,4,2,4,2,6,1,2,2,6,1,1,1,4,4,6,1,6,1,1,1,1,1,2,2,1,2,2,1,4,2,4,1,2,2,6,1,1,1,4,4,6,1,6,1,1,1,1,1,2,2,1,4,2,4,1,1,1,4,4,6,1,6,1,1,2,2,2,4,1,2,2,6,1,6,1,2,4,1,6,4,8],[[3,2,1,0,0,0],[3,1,2,0,0,0],[3,1,0,0,0,0],[3,0,1,0,0,0],[3,0,0,0,2,1],[3,0,0,0,1,2],[3,0,0,0,1,0],[3,0,0,0,0,1],[2,3,1,0,0,0],[2,2,2,0,0,0],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,1],[2,0,2,0,0,0],[2,0,1,0,1,0],[2,0,0,0,3,1],[2,0,0,0,2,2],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,1],[2,0,0,0,0,2],[2,0,0,0,0,0],[1,3,2,0,0,0],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,0],[1,0,3,0,0,0],[1,0,2,0,1,0],[1,0,1,0,2,0],[1,0,1,0,0,0],[1,0,0,0,3,2],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,1],[1,0,0,0,1,2],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,1],[0,3,1,0,0,0],[0,3,0,2,0,1],[0,3,0,1,0,2],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,0,3,0,1],[0,2,0,2,0,2],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,1],[0,2,0,0,0,2],[0,2,0,0,0,0],[0,1,3,0,0,0],[0,1,2,1,0,0],[0,1,1,2,0,0],[0,1,1,0,0,0],[0,1,0,3,0,2],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,1],[0,1,0,1,0,2],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,1],[0,0,3,2,1,0],[0,0,3,1,2,0],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,2,3,1,0],[0,0,2,2,2,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,1,0],[0,0,2,0,2,0],[0,0,2,0,0,0],[0,0,1,3,2,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,1,0],[0,0,1,1,2,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,1,0],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,2,0,0],[0,0,0,1,3,0],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,1],[0,0,0,0,3,1],[0,0,0,0,2,2],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,1],[0,0,0,0,0,2],[0,0,0,0,0,0]]], + "(3, 2, 2)": [[1,1,1,1,1,1,1,2,2,2,2,1,1,2,2,2,2,1,2,2,1,3,2,2,2,1,2,2,1,3,2,3,1,1,1,2,1,1,2,2,2,2,2,2,1,2,2,1,3,2,3,1,1,1,1,1,2,2,2,2,1,2,2,1,3,2,3,1,2,2,2,2,2,3,1,2,2,3,1,3],[[3,2,2,0,0,0],[3,1,1,0,0,0],[3,0,0,0,2,2],[3,0,0,0,1,1],[3,0,0,0,0,0],[2,3,2,0,0,0],[2,2,3,0,0,0],[2,2,1,0,0,0],[2,1,2,0,0,0],[2,1,0,0,0,0],[2,0,1,0,0,0],[2,0,0,0,3,2],[2,0,0,0,2,3],[2,0,0,0,2,1],[2,0,0,0,1,2],[2,0,0,0,1,0],[2,0,0,0,0,1],[1,3,1,0,0,0],[1,2,2,0,0,0],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,1],[1,0,2,0,0,0],[1,0,1,0,1,0],[1,0,0,0,3,1],[1,0,0,0,2,2],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,1],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,3,0,2,0,2],[0,3,0,1,0,1],[0,3,0,0,0,0],[0,2,1,0,0,0],[0,2,0,3,0,2],[0,2,0,2,0,3],[0,2,0,2,0,1],[0,2,0,1,0,2],[0,2,0,1,0,0],[0,2,0,0,0,1],[0,1,2,0,0,0],[0,1,1,1,0,0],[0,1,0,3,0,1],[0,1,0,2,0,2],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,1],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,3,2,2,0],[0,0,3,1,1,0],[0,0,3,0,0,0],[0,0,2,3,2,0],[0,0,2,2,3,0],[0,0,2,2,1,0],[0,0,2,1,2,0],[0,0,2,1,0,0],[0,0,2,0,1,0],[0,0,1,3,1,0],[0,0,1,2,2,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,1,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,3,0,0],[0,0,0,2,1,0],[0,0,0,2,0,1],[0,0,0,1,2,0],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,3,0],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]], + "(4, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,1,1,1,1,1,1,2,1,1,1,2,1,2,1,1,1,1,1,1,2,1,1,1,2,1,2,1,1,1,2,1,2,1,2,3],[[4,0,0,0,0,0],[3,1,0,0,0,0],[3,0,1,0,0,0],[3,0,0,0,1,0],[3,0,0,0,0,1],[2,2,0,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,1],[2,0,2,0,0,0],[2,0,1,0,1,0],[2,0,0,0,2,0],[2,0,0,0,1,1],[2,0,0,0,0,2],[2,0,0,0,0,0],[1,3,0,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,0],[1,0,3,0,0,0],[1,0,2,0,1,0],[1,0,1,0,2,0],[1,0,1,0,0,0],[1,0,0,0,3,0],[1,0,0,0,2,1],[1,0,0,0,1,2],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,1],[0,4,0,0,0,0],[0,3,1,0,0,0],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,0,2,0,0],[0,2,0,1,0,1],[0,2,0,0,0,2],[0,2,0,0,0,0],[0,1,3,0,0,0],[0,1,2,1,0,0],[0,1,1,2,0,0],[0,1,1,0,0,0],[0,1,0,3,0,0],[0,1,0,2,0,1],[0,1,0,1,0,2],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,1],[0,0,4,0,0,0],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,2,2,0,0],[0,0,2,1,1,0],[0,0,2,0,2,0],[0,0,2,0,0,0],[0,0,1,3,0,0],[0,0,1,2,1,0],[0,0,1,1,2,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,1,0],[0,0,0,4,0,0],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,2,0,0],[0,0,0,1,3,0],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,1],[0,0,0,0,4,0],[0,0,0,0,3,1],[0,0,0,0,2,2],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,1],[0,0,0,0,0,4],[0,0,0,0,0,2],[0,0,0,0,0,0]]], + "(4, 1, 0)": [[1,1,1,1,1,2,2,1,2,1,2,1,4,1,2,2,2,2,5,1,2,2,5,1,2,2,5,1,5,1,2,2,2,2,5,2,6,2,6,1,2,2,5,2,6,1,2,2,5,2,6,1,5,8,1,1,1,1,2,1,2,1,4,1,2,2,5,1,2,2,5,1,5,1,2,2,5,2,6,1,2,2,5,2,6,1,5,8,1,1,1,2,1,4,1,2,2,5,1,5,1,2,2,5,2,6,1,5,8,1,1,1,2,1,4,1,2,2,5,1,5,1,2,2,5,2,6,1,5,8,1,1,4,1,5,1,5,8,4,8],[[4,1,0,0,0,0],[4,0,1,0,0,0],[4,0,0,0,1,0],[4,0,0,0,0,1],[3,2,0,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,1],[3,0,2,0,0,0],[3,0,1,0,1,0],[3,0,0,0,2,0],[3,0,0,0,1,1],[3,0,0,0,0,2],[3,0,0,0,0,0],[2,3,0,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,1],[2,1,2,0,0,0],[2,1,0,0,0,2],[2,1,0,0,0,0],[2,0,3,0,0,0],[2,0,2,0,1,0],[2,0,1,0,2,0],[2,0,1,0,0,0],[2,0,0,0,3,0],[2,0,0,0,2,1],[2,0,0,0,1,2],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,1],[1,4,0,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,1],[1,2,2,0,0,0],[1,2,0,0,0,2],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,1],[1,0,4,0,0,0],[1,0,3,0,1,0],[1,0,2,0,2,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,1,0],[1,0,0,0,4,0],[1,0,0,0,3,1],[1,0,0,0,2,2],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,1],[1,0,0,0,0,4],[1,0,0,0,0,2],[1,0,0,0,0,0],[0,4,1,0,0,0],[0,4,0,1,0,0],[0,4,0,0,0,1],[0,3,2,0,0,0],[0,3,1,1,0,0],[0,3,0,2,0,0],[0,3,0,1,0,1],[0,3,0,0,0,2],[0,3,0,0,0,0],[0,2,3,0,0,0],[0,2,2,1,0,0],[0,2,1,2,0,0],[0,2,1,0,0,0],[0,2,0,3,0,0],[0,2,0,2,0,1],[0,2,0,1,0,2],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,1],[0,1,4,0,0,0],[0,1,3,1,0,0],[0,1,2,2,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,1,0,0],[0,1,0,4,0,0],[0,1,0,3,0,1],[0,1,0,2,0,2],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,1],[0,1,0,0,0,4],[0,1,0,0,0,2],[0,1,0,0,0,0],[0,0,4,1,0,0],[0,0,4,0,1,0],[0,0,3,2,0,0],[0,0,3,1,1,0],[0,0,3,0,2,0],[0,0,3,0,0,0],[0,0,2,3,0,0],[0,0,2,2,1,0],[0,0,2,1,2,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,1,0],[0,0,1,4,0,0],[0,0,1,3,1,0],[0,0,1,2,2,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,1,0],[0,0,1,0,4,0],[0,0,1,0,2,0],[0,0,1,0,0,0],[0,0,0,4,1,0],[0,0,0,4,0,1],[0,0,0,3,2,0],[0,0,0,3,1,1],[0,0,0,3,0,2],[0,0,0,3,0,0],[0,0,0,2,3,0],[0,0,0,2,2,1],[0,0,0,2,1,2],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,1],[0,0,0,1,4,0],[0,0,0,1,3,1],[0,0,0,1,2,2],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,1],[0,0,0,1,0,4],[0,0,0,1,0,2],[0,0,0,1,0,0],[0,0,0,0,4,1],[0,0,0,0,3,2],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,1],[0,0,0,0,1,4],[0,0,0,0,1,2],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,1]]] }, "SO(7)": { "(0, 0, 0)": [[1],[[0,0,0,0,0,0]]], @@ -105,9 +125,14 @@ "(3, 2, 1)": [[1,1,1,1,2,1,2,3,1,1,1,2,3,1,1,1,2,3,1,3,3,1,1,1,2,4,2,4,6,1,4,10,1,4,10,11,1,1,2,4,6,1,4,10,11,1,1,2,4,6,1,4,10,11,1,6,11,15,1,2,1,2,3,1,4,10,1,4,10,11,2,10,18,2,10,18,24,1,2,3,1,4,10,11,2,10,18,24,1,2,3,1,4,10,11,2,10,18,24,3,11,24,27,1,1,1,2,3,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,1,2,4,6,1,4,10,11,1,6,11,15,1,2,3,1,4,10,11,2,10,18,24,1,2,3,1,4,10,11,2,10,18,24,3,11,24,27,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,6,11,15,1,2,3,1,4,10,11,2,10,18,24,3,11,24,27,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,6,11,15,1,2,3,1,4,10,11,2,10,18,24,3,11,24,27,1,3,3,1,6,11,15,3,11,24,27,3,15,27,35],[[3,2,1,0,0,0],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], "(3, 2, 2)": [[1,1,1,1,1,1,2,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,2,3,1,1,1,1,1,1,3,5,1,3,5,5,1,5,8,1,5,8,10,1,1,1,1,3,5,5,1,5,8,10,1,1,1,1,3,5,5,1,5,8,10,1,5,10,11,1,2,1,2,2,1,5,8,1,5,8,10,2,8,15,2,8,15,17,1,2,2,1,5,8,10,2,8,15,17,1,2,2,1,5,8,10,2,8,15,17,2,10,17,21,1,1,1,1,2,2,1,1,1,1,2,2,1,2,3,1,1,1,1,3,5,5,1,5,8,10,1,1,1,1,3,5,5,1,5,8,10,1,5,10,11,1,2,2,1,5,8,10,2,8,15,17,1,2,2,1,5,8,10,2,8,15,17,2,10,17,21,1,1,1,1,2,2,1,2,3,1,1,1,1,3,5,5,1,5,8,10,1,5,10,11,1,2,2,1,5,8,10,2,8,15,17,2,10,17,21,1,1,1,1,2,2,1,2,3,1,1,1,1,3,5,5,1,5,8,10,1,5,10,11,1,2,2,1,5,8,10,2,8,15,17,2,10,17,21,1,2,3,1,5,10,11,2,10,17,21,3,11,21,24],[[3,2,2,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,2],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,2,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,2],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,2,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,2],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,3,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,3],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,2,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,3,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,2],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,3],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,3,2,2,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,2],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,2,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,3,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,2],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,3],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,3,2,2,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,2,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,3,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,3,2,2],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,2],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,3],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], "(3, 3, 0)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,2,1,1,2,2,1,1,1,1,2,1,2,4,1,2,5,1,2,5,5,1,1,1,2,4,1,2,5,5,1,1,1,2,4,1,2,5,5,1,4,5,7,1,1,1,1,2,1,2,5,1,2,5,5,1,5,7,1,5,7,11,1,1,2,1,2,5,5,1,5,7,11,1,1,2,1,2,5,5,1,5,7,11,2,5,11,11,1,1,1,1,1,2,1,1,1,1,1,2,1,1,2,2,1,1,1,2,4,1,2,5,5,1,1,1,2,4,1,2,5,5,1,4,5,7,1,1,2,1,2,5,5,1,5,7,11,1,1,2,1,2,5,5,1,5,7,11,2,5,11,11,1,1,1,1,1,2,1,1,2,2,1,1,1,2,4,1,2,5,5,1,4,5,7,1,1,2,1,2,5,5,1,5,7,11,2,5,11,11,1,1,1,1,1,2,1,1,2,2,1,1,1,2,4,1,2,5,5,1,4,5,7,1,1,2,1,2,5,5,1,5,7,11,2,5,11,11,1,1,2,2,1,4,5,7,2,5,11,11,2,7,11,17],[[3,3,0,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,3,0,0,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,3,0],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,3],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,3,3,0,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,3,0,0],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,3],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,3,3,0,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,3,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,3,3,0],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,3],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,3,3],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], + "(3, 3, 1)": [[1,1,1,1,2,1,2,3,1,2,4,1,2,4,4,1,1,1,2,3,1,2,4,4,1,1,1,2,3,1,2,4,4,1,3,4,5,1,2,1,2,3,1,3,7,1,3,7,8,2,7,11,2,7,11,14,1,2,3,1,3,7,8,2,7,11,14,1,2,3,1,3,7,8,2,7,11,14,3,8,14,15,1,2,4,1,2,4,4,2,7,11,2,7,11,14,4,11,21,4,11,21,23,1,2,4,4,2,7,11,14,4,11,21,23,1,2,4,4,2,7,11,14,4,11,21,23,4,14,23,29,1,1,1,2,3,1,2,4,4,1,1,1,2,3,1,2,4,4,1,3,4,5,1,2,3,1,3,7,8,2,7,11,14,1,2,3,1,3,7,8,2,7,11,14,3,8,14,15,1,2,4,4,2,7,11,14,4,11,21,23,1,2,4,4,2,7,11,14,4,11,21,23,4,14,23,29,1,1,1,2,3,1,2,4,4,1,3,4,5,1,2,3,1,3,7,8,2,7,11,14,3,8,14,15,1,2,4,4,2,7,11,14,4,11,21,23,4,14,23,29,1,1,1,2,3,1,2,4,4,1,3,4,5,1,2,3,1,3,7,8,2,7,11,14,3,8,14,15,1,2,4,4,2,7,11,14,4,11,21,23,4,14,23,29,1,3,4,5,3,8,14,15,4,14,23,29,5,15,29,33],[[3,3,1,0,0,0],[3,3,0,0,0,1],[3,3,0,0,0,0],[3,2,2,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,2],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,3,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,3],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,3,0,1,0],[3,0,3,0,0,0],[3,0,2,0,2,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,3,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,3,1],[3,0,0,0,3,0],[3,0,0,0,2,2],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,3],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,3],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,2,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,2],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,3,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,3],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,2,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,3,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,2],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,3],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,3,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,3],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,3,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,3],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,3,3,1,0,0],[0,3,3,0,0,0],[0,3,2,2,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,3,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,3,0,1],[0,3,0,3,0,0],[0,3,0,2,0,2],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,3],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,3],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,2,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,3,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,2],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,3],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,3,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,3],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,3,3,1,0],[0,0,3,3,0,0],[0,0,3,2,2,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,3,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,3,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,2,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,3,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,3,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,3,3,1],[0,0,0,3,3,0],[0,0,0,3,2,2],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,3],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,3],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,2],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,3],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,3],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,3,3],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], + "(3, 3, 2)": [[1,1,1,1,1,1,2,3,1,2,3,3,1,3,4,1,3,4,5,1,1,1,1,2,3,3,1,3,4,5,1,1,1,1,2,3,3,1,3,4,5,1,3,5,5,1,2,3,1,2,3,3,2,6,8,2,6,8,9,3,8,13,3,8,13,14,1,2,3,3,2,6,8,9,3,8,13,14,1,2,3,3,2,6,8,9,3,8,13,14,3,9,14,17,1,3,4,1,3,4,5,3,8,13,3,8,13,14,4,13,20,4,13,20,24,1,3,4,5,3,8,13,14,4,13,20,24,1,3,4,5,3,8,13,14,4,13,20,24,5,14,24,27,1,1,1,1,2,3,3,1,3,4,5,1,1,1,1,2,3,3,1,3,4,5,1,3,5,5,1,2,3,3,2,6,8,9,3,8,13,14,1,2,3,3,2,6,8,9,3,8,13,14,3,9,14,17,1,3,4,5,3,8,13,14,4,13,20,24,1,3,4,5,3,8,13,14,4,13,20,24,5,14,24,27,1,1,1,1,2,3,3,1,3,4,5,1,3,5,5,1,2,3,3,2,6,8,9,3,8,13,14,3,9,14,17,1,3,4,5,3,8,13,14,4,13,20,24,5,14,24,27,1,1,1,1,2,3,3,1,3,4,5,1,3,5,5,1,2,3,3,2,6,8,9,3,8,13,14,3,9,14,17,1,3,4,5,3,8,13,14,4,13,20,24,5,14,24,27,1,3,5,5,3,9,14,17,5,14,24,27,5,17,27,32],[[3,3,2,0,0,0],[3,3,1,0,0,0],[3,3,0,0,0,2],[3,3,0,0,0,1],[3,3,0,0,0,0],[3,2,3,0,0,0],[3,2,2,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,3],[3,2,0,0,0,2],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,3,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,3],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,3,0,2,0],[3,0,3,0,1,0],[3,0,3,0,0,0],[3,0,2,0,3,0],[3,0,2,0,2,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,3,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,3,2],[3,0,0,0,3,1],[3,0,0,0,3,0],[3,0,0,0,2,3],[3,0,0,0,2,2],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,3],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,3],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,3,0,0,0],[2,3,2,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,3],[2,3,0,0,0,2],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,3,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,3],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,3,0],[2,0,3,0,2,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,3,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,3],[2,0,0,0,3,2],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,3],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,3,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,3],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,3,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,3],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,3,3,2,0,0],[0,3,3,1,0,0],[0,3,3,0,0,0],[0,3,2,3,0,0],[0,3,2,2,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,3,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,3,0,2],[0,3,0,3,0,1],[0,3,0,3,0,0],[0,3,0,2,0,3],[0,3,0,2,0,2],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,3],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,3],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,3,0,0],[0,2,3,2,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,3,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,3],[0,2,0,3,0,2],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,3],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,3,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,3],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,3,3,2,0],[0,0,3,3,1,0],[0,0,3,3,0,0],[0,0,3,2,3,0],[0,0,3,2,2,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,3,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,3,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,3,0],[0,0,2,3,2,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,3,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,3,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,3,3,2],[0,0,0,3,3,1],[0,0,0,3,3,0],[0,0,0,3,2,3],[0,0,0,3,2,2],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,3],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,3],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,3],[0,0,0,2,3,2],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,3],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,3],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,3,3],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], "(4, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6],[[4,0,0,0,0,0],[3,1,0,0,0,0],[3,0,1,0,0,0],[3,0,0,0,1,0],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,2,0,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,2,0,0,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,2,0],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,3,0,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,3,0,0,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,3,0],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,0,0,0,0],[0,3,1,0,0,0],[0,3,0,1,0,0],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,2,0,0],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,3,0,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,3,0,0],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,0,0,0],[0,0,3,1,0,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,2,0,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,3,0,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,0,0],[0,0,0,3,1,0],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,3,0],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,0],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], "(4, 1, 0)": [[1,1,1,1,1,1,2,2,2,1,2,2,1,2,2,1,2,5,1,2,2,2,2,3,2,3,7,1,2,2,2,3,7,1,2,2,2,3,7,1,2,7,7,1,2,2,2,2,3,2,3,7,2,3,9,2,3,9,9,1,2,2,2,3,7,2,3,9,9,1,2,2,2,3,7,2,3,9,9,1,2,7,9,15,1,1,1,1,1,2,2,1,2,2,1,2,5,1,2,2,2,3,7,1,2,2,2,3,7,1,2,7,7,1,2,2,2,3,7,2,3,9,9,1,2,2,2,3,7,2,3,9,9,1,2,7,9,15,1,1,1,1,2,2,1,2,5,1,2,2,2,3,7,1,2,7,7,1,2,2,2,3,7,2,3,9,9,1,2,7,9,15,1,1,1,1,2,2,1,2,5,1,2,2,2,3,7,1,2,7,7,1,2,2,2,3,7,2,3,9,9,1,2,7,9,15,1,1,1,2,5,1,2,7,7,1,2,7,9,15,1,5,7,15,15],[[4,1,0,0,0,0],[4,0,1,0,0,0],[4,0,0,0,1,0],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,2,0,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,0,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,0],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,0,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,0,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,0],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,0,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,0,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,0],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,1,0,0,0],[0,4,0,1,0,0],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,2,0,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,0],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,0,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,0],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,0,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,0],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,1,0,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,2,0,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,0,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,0,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,1,0],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,2,0],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,0],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,0],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], - "(4, 1, 1)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,3,1,3,5,1,1,1,3,5,1,1,1,3,5,1,5,6,1,1,1,1,3,1,3,5,1,3,9,1,3,9,10,1,1,1,3,5,1,3,9,10,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,1,3,1,3,5,1,3,9,1,3,9,10,1,3,9,15,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,1,1,2,1,1,1,3,5,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,2,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,2,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,2,1,5,6,1,5,10,14,1,5,10,20,22,2,6,14,22,28],[[4,1,1,0,0,0],[4,1,0,0,0,1],[4,1,0,0,0,0],[4,0,1,0,1,0],[4,0,1,0,0,0],[4,0,0,0,1,1],[4,0,0,0,1,0],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,1,0,0,0],[1,4,0,0,0,1],[1,4,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,4,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,4],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,1,0],[1,0,4,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,4,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,1],[1,0,0,0,4,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,4],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,1,1,0,0],[0,4,1,0,0,0],[0,4,0,1,0,1],[0,4,0,1,0,0],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,1,0,0],[0,1,4,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,4,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,1],[0,1,0,4,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,4],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,1,1,0],[0,0,4,1,0,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,1,0],[0,0,1,4,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,4,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,1,1],[0,0,0,4,1,0],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,1],[0,0,0,1,4,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,4],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]] + "(4, 1, 1)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,3,1,3,5,1,1,1,3,5,1,1,1,3,5,1,5,6,1,1,1,1,3,1,3,5,1,3,9,1,3,9,10,1,1,1,3,5,1,3,9,10,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,1,3,1,3,5,1,3,9,1,3,9,10,1,3,9,15,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,1,1,2,1,1,1,3,5,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,2,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,1,1,2,1,1,1,3,5,1,5,6,1,1,1,3,5,1,3,9,10,1,5,10,14,1,1,1,3,5,1,3,9,10,1,3,9,15,20,1,5,10,20,22,1,2,1,5,6,1,5,10,14,1,5,10,20,22,2,6,14,22,28],[[4,1,1,0,0,0],[4,1,0,0,0,1],[4,1,0,0,0,0],[4,0,1,0,1,0],[4,0,1,0,0,0],[4,0,0,0,1,1],[4,0,0,0,1,0],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,1,0,0,0],[1,4,0,0,0,1],[1,4,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,4,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,4],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,1,0],[1,0,4,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,4,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,1],[1,0,0,0,4,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,4],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,1,1,0,0],[0,4,1,0,0,0],[0,4,0,1,0,1],[0,4,0,1,0,0],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,1,0,0],[0,1,4,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,4,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,1],[0,1,0,4,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,4],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,1,1,0],[0,0,4,1,0,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,1,0],[0,0,1,4,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,4,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,1,1],[0,0,0,4,1,0],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,1],[0,0,0,1,4,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,4],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], + "(4, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,3,2,3,6,1,2,2,2,3,6,1,2,2,2,3,6,1,2,6,6,1,2,2,2,3,4,3,4,8,2,4,11,2,4,11,11,1,2,2,3,4,8,2,4,11,11,1,2,2,3,4,8,2,4,11,11,1,2,8,11,18,1,1,1,2,3,2,3,6,2,4,11,2,4,11,11,1,3,11,15,1,3,11,15,23,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,6,11,23,23,1,1,1,1,1,1,1,1,2,1,2,2,2,3,6,1,2,2,2,3,6,1,2,6,6,1,2,2,3,4,8,2,4,11,11,1,2,2,3,4,8,2,4,11,11,1,2,8,11,18,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,6,11,23,23,1,1,1,1,1,2,1,2,2,2,3,6,1,2,6,6,1,2,2,3,4,8,2,4,11,11,1,2,8,11,18,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,6,11,23,23,1,1,1,1,1,2,1,2,2,2,3,6,1,2,6,6,1,2,2,3,4,8,2,4,11,11,1,2,8,11,18,1,1,2,3,6,2,4,11,11,1,3,11,15,23,1,6,11,23,23,1,1,2,1,2,6,6,1,2,8,11,18,1,6,11,23,23,2,6,18,23,33],[[4,2,0,0,0,0],[4,1,1,0,0,0],[4,1,0,0,0,1],[4,1,0,0,0,0],[4,0,2,0,0,0],[4,0,1,0,1,0],[4,0,1,0,0,0],[4,0,0,0,2,0],[4,0,0,0,1,1],[4,0,0,0,1,0],[4,0,0,0,0,2],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,3,0,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,3,0,0,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,3,0],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,3],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,4,0,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,4,0,0,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,4,0],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,4],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,1,0,0,0],[1,4,0,0,0,1],[1,4,0,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,4,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,4],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,1,0],[1,0,4,0,0,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,4,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,1],[1,0,0,0,4,0],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,4],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,2,0,0,0],[0,4,1,1,0,0],[0,4,1,0,0,0],[0,4,0,2,0,0],[0,4,0,1,0,1],[0,4,0,1,0,0],[0,4,0,0,0,2],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,3,0,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,3,0,0],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,3],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,4,0,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,4,0,0],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,4],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,1,0,0],[0,1,4,0,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,4,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,1],[0,1,0,4,0,0],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,4],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,2,0,0],[0,0,4,1,1,0],[0,0,4,1,0,0],[0,0,4,0,2,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,3,0,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,3,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,4,0,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,4,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,1,0],[0,0,1,4,0,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,4,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,2,0],[0,0,0,4,1,1],[0,0,0,4,1,0],[0,0,0,4,0,2],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,3,0],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,3],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,4,0],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,4],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,1],[0,0,0,1,4,0],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,4],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,2],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,3],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,4],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], + "(4, 2, 1)": [[1,1,1,1,2,1,2,3,1,1,1,2,3,1,1,1,2,3,1,3,3,1,1,1,2,4,2,4,6,1,4,10,1,4,10,11,1,1,2,4,6,1,4,10,11,1,1,2,4,6,1,4,10,11,1,6,11,15,1,1,1,2,4,2,4,6,2,6,14,2,6,14,15,1,4,14,23,1,4,14,23,30,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,6,15,30,33,1,2,1,2,3,1,4,10,1,4,10,11,1,4,14,23,1,4,14,23,30,2,10,23,42,2,10,23,42,46,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,3,11,30,46,57,1,1,1,2,3,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,1,2,4,6,1,4,10,11,1,6,11,15,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,6,15,30,33,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,3,11,30,46,57,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,6,11,15,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,6,15,30,33,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,3,11,30,46,57,1,1,1,2,3,1,3,3,1,1,2,4,6,1,4,10,11,1,6,11,15,1,1,2,4,6,2,6,14,15,1,4,14,23,30,1,6,15,30,33,1,2,3,1,4,10,11,1,4,14,23,30,2,10,23,42,46,3,11,30,46,57,1,3,3,1,6,11,15,1,6,15,30,33,3,11,30,46,57,3,15,33,57,62],[[4,2,1,0,0,0],[4,2,0,0,0,1],[4,2,0,0,0,0],[4,1,2,0,0,0],[4,1,1,0,0,0],[4,1,0,0,0,2],[4,1,0,0,0,1],[4,1,0,0,0,0],[4,0,2,0,1,0],[4,0,2,0,0,0],[4,0,1,0,2,0],[4,0,1,0,1,0],[4,0,1,0,0,0],[4,0,0,0,2,1],[4,0,0,0,2,0],[4,0,0,0,1,2],[4,0,0,0,1,1],[4,0,0,0,1,0],[4,0,0,0,0,2],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,3,1,0,0,0],[3,3,0,0,0,1],[3,3,0,0,0,0],[3,2,2,0,0,0],[3,2,1,0,0,0],[3,2,0,0,0,2],[3,2,0,0,0,1],[3,2,0,0,0,0],[3,1,3,0,0,0],[3,1,2,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,3],[3,1,0,0,0,2],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,3,0,1,0],[3,0,3,0,0,0],[3,0,2,0,2,0],[3,0,2,0,1,0],[3,0,2,0,0,0],[3,0,1,0,3,0],[3,0,1,0,2,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,3,1],[3,0,0,0,3,0],[3,0,0,0,2,2],[3,0,0,0,2,1],[3,0,0,0,2,0],[3,0,0,0,1,3],[3,0,0,0,1,2],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,3],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,4,1,0,0,0],[2,4,0,0,0,1],[2,4,0,0,0,0],[2,3,2,0,0,0],[2,3,1,0,0,0],[2,3,0,0,0,2],[2,3,0,0,0,1],[2,3,0,0,0,0],[2,2,3,0,0,0],[2,2,2,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,3],[2,2,0,0,0,2],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,4,0,0,0],[2,1,3,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,4],[2,1,0,0,0,3],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,4,0,1,0],[2,0,4,0,0,0],[2,0,3,0,2,0],[2,0,3,0,1,0],[2,0,3,0,0,0],[2,0,2,0,3,0],[2,0,2,0,2,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,4,0],[2,0,1,0,3,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,4,1],[2,0,0,0,4,0],[2,0,0,0,3,2],[2,0,0,0,3,1],[2,0,0,0,3,0],[2,0,0,0,2,3],[2,0,0,0,2,2],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,4],[2,0,0,0,1,3],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,4],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,2,0,0,0],[1,4,1,0,0,0],[1,4,0,0,0,2],[1,4,0,0,0,1],[1,4,0,0,0,0],[1,3,3,0,0,0],[1,3,2,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,3],[1,3,0,0,0,2],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,4,0,0,0],[1,2,3,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,4],[1,2,0,0,0,3],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,4,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,4],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,2,0],[1,0,4,0,1,0],[1,0,4,0,0,0],[1,0,3,0,3,0],[1,0,3,0,2,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,4,0],[1,0,2,0,3,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,4,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,2],[1,0,0,0,4,1],[1,0,0,0,4,0],[1,0,0,0,3,3],[1,0,0,0,3,2],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,4],[1,0,0,0,2,3],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,4],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,4,2,1,0,0],[0,4,2,0,0,0],[0,4,1,2,0,0],[0,4,1,1,0,0],[0,4,1,0,0,0],[0,4,0,2,0,1],[0,4,0,2,0,0],[0,4,0,1,0,2],[0,4,0,1,0,1],[0,4,0,1,0,0],[0,4,0,0,0,2],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,3,1,0,0],[0,3,3,0,0,0],[0,3,2,2,0,0],[0,3,2,1,0,0],[0,3,2,0,0,0],[0,3,1,3,0,0],[0,3,1,2,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,3,0,1],[0,3,0,3,0,0],[0,3,0,2,0,2],[0,3,0,2,0,1],[0,3,0,2,0,0],[0,3,0,1,0,3],[0,3,0,1,0,2],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,3],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,4,1,0,0],[0,2,4,0,0,0],[0,2,3,2,0,0],[0,2,3,1,0,0],[0,2,3,0,0,0],[0,2,2,3,0,0],[0,2,2,2,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,4,0,0],[0,2,1,3,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,4,0,1],[0,2,0,4,0,0],[0,2,0,3,0,2],[0,2,0,3,0,1],[0,2,0,3,0,0],[0,2,0,2,0,3],[0,2,0,2,0,2],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,4],[0,2,0,1,0,3],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,4],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,2,0,0],[0,1,4,1,0,0],[0,1,4,0,0,0],[0,1,3,3,0,0],[0,1,3,2,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,4,0,0],[0,1,2,3,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,4,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,2],[0,1,0,4,0,1],[0,1,0,4,0,0],[0,1,0,3,0,3],[0,1,0,3,0,2],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,4],[0,1,0,2,0,3],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,4],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,4,2,1,0],[0,0,4,2,0,0],[0,0,4,1,2,0],[0,0,4,1,1,0],[0,0,4,1,0,0],[0,0,4,0,2,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,3,1,0],[0,0,3,3,0,0],[0,0,3,2,2,0],[0,0,3,2,1,0],[0,0,3,2,0,0],[0,0,3,1,3,0],[0,0,3,1,2,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,3,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,4,1,0],[0,0,2,4,0,0],[0,0,2,3,2,0],[0,0,2,3,1,0],[0,0,2,3,0,0],[0,0,2,2,3,0],[0,0,2,2,2,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,4,0],[0,0,2,1,3,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,4,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,2,0],[0,0,1,4,1,0],[0,0,1,4,0,0],[0,0,1,3,3,0],[0,0,1,3,2,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,4,0],[0,0,1,2,3,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,4,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,4,2,1],[0,0,0,4,2,0],[0,0,0,4,1,2],[0,0,0,4,1,1],[0,0,0,4,1,0],[0,0,0,4,0,2],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,3,1],[0,0,0,3,3,0],[0,0,0,3,2,2],[0,0,0,3,2,1],[0,0,0,3,2,0],[0,0,0,3,1,3],[0,0,0,3,1,2],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,3],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,4,1],[0,0,0,2,4,0],[0,0,0,2,3,2],[0,0,0,2,3,1],[0,0,0,2,3,0],[0,0,0,2,2,3],[0,0,0,2,2,2],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,4],[0,0,0,2,1,3],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,4],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,2],[0,0,0,1,4,1],[0,0,0,1,4,0],[0,0,0,1,3,3],[0,0,0,1,3,2],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,4],[0,0,0,1,2,3],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,4],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,4,2],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,3],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,4],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]], + "(5, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,3,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6,1,1,1,1,1,3,1,1,3,3,1,1,3,3,6,1,1,3,3,6,6],[[5,0,0,0,0,0],[4,1,0,0,0,0],[4,0,1,0,0,0],[4,0,0,0,1,0],[4,0,0,0,0,1],[4,0,0,0,0,0],[3,2,0,0,0,0],[3,1,1,0,0,0],[3,1,0,0,0,1],[3,1,0,0,0,0],[3,0,2,0,0,0],[3,0,1,0,1,0],[3,0,1,0,0,0],[3,0,0,0,2,0],[3,0,0,0,1,1],[3,0,0,0,1,0],[3,0,0,0,0,2],[3,0,0,0,0,1],[3,0,0,0,0,0],[2,3,0,0,0,0],[2,2,1,0,0,0],[2,2,0,0,0,1],[2,2,0,0,0,0],[2,1,2,0,0,0],[2,1,1,0,0,0],[2,1,0,0,0,2],[2,1,0,0,0,1],[2,1,0,0,0,0],[2,0,3,0,0,0],[2,0,2,0,1,0],[2,0,2,0,0,0],[2,0,1,0,2,0],[2,0,1,0,1,0],[2,0,1,0,0,0],[2,0,0,0,3,0],[2,0,0,0,2,1],[2,0,0,0,2,0],[2,0,0,0,1,2],[2,0,0,0,1,1],[2,0,0,0,1,0],[2,0,0,0,0,3],[2,0,0,0,0,2],[2,0,0,0,0,1],[2,0,0,0,0,0],[1,4,0,0,0,0],[1,3,1,0,0,0],[1,3,0,0,0,1],[1,3,0,0,0,0],[1,2,2,0,0,0],[1,2,1,0,0,0],[1,2,0,0,0,2],[1,2,0,0,0,1],[1,2,0,0,0,0],[1,1,3,0,0,0],[1,1,2,0,0,0],[1,1,1,0,0,0],[1,1,0,0,0,3],[1,1,0,0,0,2],[1,1,0,0,0,1],[1,1,0,0,0,0],[1,0,4,0,0,0],[1,0,3,0,1,0],[1,0,3,0,0,0],[1,0,2,0,2,0],[1,0,2,0,1,0],[1,0,2,0,0,0],[1,0,1,0,3,0],[1,0,1,0,2,0],[1,0,1,0,1,0],[1,0,1,0,0,0],[1,0,0,0,4,0],[1,0,0,0,3,1],[1,0,0,0,3,0],[1,0,0,0,2,2],[1,0,0,0,2,1],[1,0,0,0,2,0],[1,0,0,0,1,3],[1,0,0,0,1,2],[1,0,0,0,1,1],[1,0,0,0,1,0],[1,0,0,0,0,4],[1,0,0,0,0,3],[1,0,0,0,0,2],[1,0,0,0,0,1],[1,0,0,0,0,0],[0,5,0,0,0,0],[0,4,1,0,0,0],[0,4,0,1,0,0],[0,4,0,0,0,1],[0,4,0,0,0,0],[0,3,2,0,0,0],[0,3,1,1,0,0],[0,3,1,0,0,0],[0,3,0,2,0,0],[0,3,0,1,0,1],[0,3,0,1,0,0],[0,3,0,0,0,2],[0,3,0,0,0,1],[0,3,0,0,0,0],[0,2,3,0,0,0],[0,2,2,1,0,0],[0,2,2,0,0,0],[0,2,1,2,0,0],[0,2,1,1,0,0],[0,2,1,0,0,0],[0,2,0,3,0,0],[0,2,0,2,0,1],[0,2,0,2,0,0],[0,2,0,1,0,2],[0,2,0,1,0,1],[0,2,0,1,0,0],[0,2,0,0,0,3],[0,2,0,0,0,2],[0,2,0,0,0,1],[0,2,0,0,0,0],[0,1,4,0,0,0],[0,1,3,1,0,0],[0,1,3,0,0,0],[0,1,2,2,0,0],[0,1,2,1,0,0],[0,1,2,0,0,0],[0,1,1,3,0,0],[0,1,1,2,0,0],[0,1,1,1,0,0],[0,1,1,0,0,0],[0,1,0,4,0,0],[0,1,0,3,0,1],[0,1,0,3,0,0],[0,1,0,2,0,2],[0,1,0,2,0,1],[0,1,0,2,0,0],[0,1,0,1,0,3],[0,1,0,1,0,2],[0,1,0,1,0,1],[0,1,0,1,0,0],[0,1,0,0,0,4],[0,1,0,0,0,3],[0,1,0,0,0,2],[0,1,0,0,0,1],[0,1,0,0,0,0],[0,0,5,0,0,0],[0,0,4,1,0,0],[0,0,4,0,1,0],[0,0,4,0,0,0],[0,0,3,2,0,0],[0,0,3,1,1,0],[0,0,3,1,0,0],[0,0,3,0,2,0],[0,0,3,0,1,0],[0,0,3,0,0,0],[0,0,2,3,0,0],[0,0,2,2,1,0],[0,0,2,2,0,0],[0,0,2,1,2,0],[0,0,2,1,1,0],[0,0,2,1,0,0],[0,0,2,0,3,0],[0,0,2,0,2,0],[0,0,2,0,1,0],[0,0,2,0,0,0],[0,0,1,4,0,0],[0,0,1,3,1,0],[0,0,1,3,0,0],[0,0,1,2,2,0],[0,0,1,2,1,0],[0,0,1,2,0,0],[0,0,1,1,3,0],[0,0,1,1,2,0],[0,0,1,1,1,0],[0,0,1,1,0,0],[0,0,1,0,4,0],[0,0,1,0,3,0],[0,0,1,0,2,0],[0,0,1,0,1,0],[0,0,1,0,0,0],[0,0,0,5,0,0],[0,0,0,4,1,0],[0,0,0,4,0,1],[0,0,0,4,0,0],[0,0,0,3,2,0],[0,0,0,3,1,1],[0,0,0,3,1,0],[0,0,0,3,0,2],[0,0,0,3,0,1],[0,0,0,3,0,0],[0,0,0,2,3,0],[0,0,0,2,2,1],[0,0,0,2,2,0],[0,0,0,2,1,2],[0,0,0,2,1,1],[0,0,0,2,1,0],[0,0,0,2,0,3],[0,0,0,2,0,2],[0,0,0,2,0,1],[0,0,0,2,0,0],[0,0,0,1,4,0],[0,0,0,1,3,1],[0,0,0,1,3,0],[0,0,0,1,2,2],[0,0,0,1,2,1],[0,0,0,1,2,0],[0,0,0,1,1,3],[0,0,0,1,1,2],[0,0,0,1,1,1],[0,0,0,1,1,0],[0,0,0,1,0,4],[0,0,0,1,0,3],[0,0,0,1,0,2],[0,0,0,1,0,1],[0,0,0,1,0,0],[0,0,0,0,5,0],[0,0,0,0,4,1],[0,0,0,0,4,0],[0,0,0,0,3,2],[0,0,0,0,3,1],[0,0,0,0,3,0],[0,0,0,0,2,3],[0,0,0,0,2,2],[0,0,0,0,2,1],[0,0,0,0,2,0],[0,0,0,0,1,4],[0,0,0,0,1,3],[0,0,0,0,1,2],[0,0,0,0,1,1],[0,0,0,0,1,0],[0,0,0,0,0,5],[0,0,0,0,0,4],[0,0,0,0,0,3],[0,0,0,0,0,2],[0,0,0,0,0,1],[0,0,0,0,0,0]]] }, "SO(8)": { "(0, 0, 0, 0)": [[1],[[0,0,0,0,0,0,0,0]]], @@ -125,33 +150,28 @@ "(2, 2, 1, -1)": [[1,1,1,1,1,2,1,1,2,2,2,1,1,1,1,2,2,2,1,2,2,1,1,1,1,2,2,1,2,1,3,1,1,2,1,1,2,2,2,1,2,3,6,1,2,6,2,3,2,8,1,1,2,2,2,1,2,6,2,3,2,8,2,2,2,3,2,8,1,1,2,2,1,2,6,2,8,2,2,8,8,1,1,1,1,2,2,2,1,2,2,1,1,1,1,2,2,1,2,1,3,1,1,2,2,2,1,2,6,2,3,2,8,2,2,2,3,2,8,1,1,2,2,1,2,6,2,8,2,2,8,8,1,2,2,1,1,1,1,2,2,1,2,1,3,2,2,2,3,2,8,1,1,2,2,1,2,6,2,8,2,2,8,8,1,1,1,1,2,2,1,2,1,3,1,1,2,2,1,2,6,2,8,2,2,8,8,1,2,2,1,2,1,3,2,2,2,3,2,8,2,2,8,8,1,2,1,3,2,2,8,8,1,3,8,3,15],[[2,2,1,0,0,0,0,1],[2,2,0,1,0,0,1,0],[2,2,0,0,0,0,0,0],[2,1,2,0,0,0,0,1],[2,1,1,0,0,0,0,2],[2,1,1,0,0,0,0,0],[2,1,0,2,0,0,1,0],[2,1,0,1,0,0,2,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,1,0,1,0,0],[2,0,2,0,0,0,0,0],[2,0,1,2,0,1,0,0],[2,0,1,1,0,2,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,0,0,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,1,1],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,2,1],[2,0,0,0,0,1,1,2],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,2,2,0,0,0,0,1],[1,2,1,0,0,0,0,2],[1,2,1,0,0,0,0,0],[1,2,0,2,0,0,1,0],[1,2,0,1,0,0,2,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,2,0,0,0,0,2],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,2,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,2,2,0,1,0,0],[1,0,2,1,0,2,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,2,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,2,1],[1,0,0,0,0,2,1,2],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,2],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,2,2,1,1,0,0,0],[0,2,2,0,0,0,0,0],[0,2,1,2,1,0,0,0],[0,2,1,1,2,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,0,0,0,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,1,1],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,2,1],[0,2,0,0,1,0,1,2],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,2,2,1,0,0,0],[0,1,2,1,2,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,2,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,2,1],[0,1,0,0,2,0,1,2],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,2],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,2,2,0,0,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,1,0,1],[0,0,2,0,2,0,0,0],[0,0,2,0,1,2,0,1],[0,0,2,0,1,1,0,2],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,2,0,1],[0,0,1,0,2,1,0,2],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,2],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,0,2,2,1,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,2,1,0],[0,0,0,2,1,1,2,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,2,1,0],[0,0,0,1,2,1,2,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,2,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], "(2, 2, 1, 0)": [[1,1,1,1,1,2,2,1,2,1,2,1,4,1,1,1,1,2,1,2,1,4,1,1,1,2,1,4,1,1,1,2,1,4,1,1,4,4,1,2,2,1,2,1,2,1,4,2,2,2,2,9,2,2,9,2,2,9,9,1,2,1,2,1,4,2,2,9,2,2,9,9,1,2,1,4,2,2,9,9,1,2,1,4,2,2,9,9,1,4,9,4,17,1,1,1,1,2,1,2,1,4,1,1,1,2,1,4,1,1,1,2,1,4,1,1,4,4,1,2,1,2,1,4,2,2,9,2,2,9,9,1,2,1,4,2,2,9,9,1,2,1,4,2,2,9,9,1,4,9,4,17,1,1,1,2,1,4,1,1,1,2,1,4,1,1,4,4,1,2,1,4,2,2,9,9,1,2,1,4,2,2,9,9,1,4,9,4,17,1,1,1,2,1,4,1,1,4,4,1,2,1,4,2,2,9,9,1,4,9,4,17,1,1,1,2,1,4,1,1,4,4,1,2,1,4,2,2,9,9,1,4,9,4,17,1,1,4,4,1,4,9,4,17,4,4,17,17],[[2,2,1,0,0,0,0,0],[2,2,0,1,0,0,0,0],[2,2,0,0,0,0,1,0],[2,2,0,0,0,0,0,1],[2,1,2,0,0,0,0,0],[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,0,2,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,0,0,0,2,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,0,2],[2,1,0,0,0,0,0,0],[2,0,2,1,0,0,0,0],[2,0,2,0,0,1,0,0],[2,0,2,0,0,0,0,1],[2,0,1,2,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,0,0,2,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,0,0,2],[2,0,1,0,0,0,0,0],[2,0,0,2,0,1,0,0],[2,0,0,2,0,0,1,0],[2,0,0,1,0,2,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,0,2,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,2,1,0],[2,0,0,0,0,2,0,1],[2,0,0,0,0,1,2,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,0,2],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,2,1],[2,0,0,0,0,0,1,2],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,2,2,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,0,2,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,0,0,0,2,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,0,2],[1,2,0,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,1,2,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,2,2,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,0,0,2,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,0,0,2],[1,0,2,0,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,0,2,0,2,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,0,2,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,2,2,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,0,2],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,2,2],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,2,2,1,0,0,0,0],[0,2,2,0,1,0,0,0],[0,2,2,0,0,0,0,1],[0,2,1,2,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,0,2,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,2,1,0,0,0],[0,2,0,2,0,0,1,0],[0,2,0,1,2,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,0,0,2,0],[0,2,0,1,0,0,0,0],[0,2,0,0,2,0,1,0],[0,2,0,0,2,0,0,1],[0,2,0,0,1,0,2,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,0,2],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,2,1],[0,2,0,0,0,0,1,2],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,2,2,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,0,2,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,0,0,0,2],[0,1,2,0,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,0,2,2,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,0,0,2,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,0,2,0,2,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,0,2],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,2,2],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,2,2,1,0,0,0],[0,0,2,2,0,1,0,0],[0,0,2,1,2,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,0,2,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,2,1,0,0],[0,0,2,0,2,0,0,1],[0,0,2,0,1,2,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,0,0,2],[0,0,2,0,1,0,0,0],[0,0,2,0,0,2,0,1],[0,0,2,0,0,1,0,2],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,1,2,2,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,0,2,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,2,2,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,0,0,2],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,2,0,2],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,2,2,1,0,0],[0,0,0,2,2,0,1,0],[0,0,0,2,1,2,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,0,2,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,2,1,0],[0,0,0,2,0,1,2,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,1,2,2,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,0,2,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,2,2,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,2,1,0],[0,0,0,0,2,2,0,1],[0,0,0,0,2,1,2,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,2,1],[0,0,0,0,2,0,1,2],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,2,2,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,0,2],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,2,2],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,2,1],[0,0,0,0,0,2,1,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,2,2],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]]], "(2, 2, 1, 1)": [[1,1,1,1,1,2,2,1,1,2,2,1,1,2,1,1,2,2,1,1,1,1,2,2,1,2,2,1,2,1,3,1,1,2,2,1,1,2,2,1,2,6,3,2,3,1,2,6,2,8,2,1,1,2,2,2,3,1,2,6,2,8,1,1,2,2,1,2,6,2,8,2,2,2,3,2,8,2,2,8,8,1,1,2,1,1,2,2,1,1,1,1,2,2,1,2,2,1,2,1,3,2,1,1,2,2,2,3,1,2,6,2,8,1,1,2,2,1,2,6,2,8,2,2,2,3,2,8,2,2,8,8,1,1,1,1,2,2,1,2,2,1,2,1,3,1,1,2,2,1,2,6,2,8,2,2,2,3,2,8,2,2,8,8,1,2,2,1,2,1,3,2,2,2,3,2,8,2,2,8,8,1,1,1,1,2,2,1,2,1,3,1,1,2,2,1,2,6,2,8,2,2,8,8,1,2,1,3,2,2,8,8,1,3,8,3,15],[[2,2,1,1,0,0,0,0],[2,2,0,0,0,0,1,1],[2,2,0,0,0,0,0,0],[2,1,2,1,0,0,0,0],[2,1,1,2,0,0,0,0],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,2,1],[2,1,0,0,0,0,1,2],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,0,0,1,0,1],[2,0,2,0,0,0,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,2,0,1],[2,0,1,0,0,1,0,2],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,1,1,0],[2,0,0,2,0,0,0,0],[2,0,0,1,0,2,1,0],[2,0,0,1,0,1,2,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,2,2,1,0,0,0,0],[1,2,1,2,0,0,0,0],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,2,1],[1,2,0,0,0,0,1,2],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,2,2,0,0,0,0],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,2],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,2,0,1],[1,0,2,0,0,1,0,2],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,2],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,2,0,2,1,0],[1,0,0,2,0,1,2,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,2,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,2,2,0,1,0,0,1],[0,2,2,0,0,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,2,0,0,1],[0,2,1,0,1,0,0,2],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,1,0,1,0],[0,2,0,2,0,0,0,0],[0,2,0,1,2,0,1,0],[0,2,0,1,1,0,2,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,2,0,0,1],[0,1,2,0,1,0,0,2],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,2],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,2,2,0,1,0],[0,1,0,2,1,0,2,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,2,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,2,2,1,1,0,0],[0,0,2,2,0,0,0,0],[0,0,2,1,2,1,0,0],[0,0,2,1,1,2,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,0,0,0],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,2,2,1,0,0],[0,0,1,2,1,2,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,2,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,0,2,2,0,0,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,2,2,1,1],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,2,1],[0,0,0,0,2,1,1,2],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,2,1],[0,0,0,0,1,2,1,2],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,2],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], + "(2, 2, 2, -1)": [[1,1,1,1,1,1,1,1,1,1,1,3,1,1,3,1,1,1,3,1,1,1,1,1,1,1,3,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,3,1,1,3,1,1,1,3,1,3,1,3,6,3,3,6,1,1,6,6,1,1,3,1,1,1,3,3,3,6,1,1,6,6,1,1,1,3,1,1,6,6,1,1,3,1,3,3,3,6,6,1,3,6,3,10,1,1,1,1,1,1,1,3,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,3,1,1,1,3,3,3,6,1,1,6,6,1,1,1,3,1,1,6,6,1,1,3,1,3,3,3,6,6,1,3,6,3,10,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,3,1,1,6,6,1,1,3,1,3,3,3,6,6,1,3,6,3,10,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,3,1,3,3,3,6,6,1,3,6,3,10,1,1,1,1,1,3,1,1,3,3,1,1,1,3,1,1,6,6,1,3,6,3,10,1,1,3,3,1,3,6,3,10,3,3,10,10],[[2,2,2,0,0,0,0,1],[2,2,1,0,0,0,0,2],[2,2,1,0,0,0,0,0],[2,2,0,2,0,0,1,0],[2,2,0,1,0,0,2,0],[2,2,0,1,0,0,0,0],[2,2,0,0,0,0,1,0],[2,2,0,0,0,0,0,1],[2,1,2,0,0,0,0,2],[2,1,2,0,0,0,0,0],[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,0,2,0,0,2,0],[2,1,0,2,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,0,0,0,2,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,0,2],[2,1,0,0,0,0,0,0],[2,0,2,2,0,1,0,0],[2,0,2,1,0,2,0,0],[2,0,2,1,0,0,0,0],[2,0,2,0,0,1,0,0],[2,0,2,0,0,0,0,1],[2,0,1,2,0,2,0,0],[2,0,1,2,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,0,0,2,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,0,0,2],[2,0,1,0,0,0,0,0],[2,0,0,2,0,1,0,0],[2,0,0,2,0,0,1,0],[2,0,0,1,0,2,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,0,2,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,2,2,1],[2,0,0,0,0,2,1,2],[2,0,0,0,0,2,1,0],[2,0,0,0,0,2,0,1],[2,0,0,0,0,1,2,2],[2,0,0,0,0,1,2,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,0,2],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,2,1],[2,0,0,0,0,0,1,2],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,2,2,0,0,0,0,2],[1,2,2,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,0,2,0,0,2,0],[1,2,0,2,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,0,0,0,2,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,0,2],[1,2,0,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,1,2,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,2,2,0,2,0,0],[1,0,2,2,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,0,0,2,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,0,0,2],[1,0,2,0,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,0,2,0,2,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,0,2,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,2,2,2],[1,0,0,0,0,2,2,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,0,2],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,2,2],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,2,2,2,1,0,0,0],[0,2,2,1,2,0,0,0],[0,2,2,1,0,0,0,0],[0,2,2,0,1,0,0,0],[0,2,2,0,0,0,0,1],[0,2,1,2,2,0,0,0],[0,2,1,2,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,0,2,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,2,1,0,0,0],[0,2,0,2,0,0,1,0],[0,2,0,1,2,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,0,0,2,0],[0,2,0,1,0,0,0,0],[0,2,0,0,2,0,2,1],[0,2,0,0,2,0,1,2],[0,2,0,0,2,0,1,0],[0,2,0,0,2,0,0,1],[0,2,0,0,1,0,2,2],[0,2,0,0,1,0,2,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,0,2],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,2,1],[0,2,0,0,0,0,1,2],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,2,2,2,0,0,0],[0,1,2,2,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,0,2,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,0,0,0,2],[0,1,2,0,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,0,2,2,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,0,0,2,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,0,2,0,2,2],[0,1,0,0,2,0,2,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,0,2],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,2,2],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,2,2,1,0,0,0],[0,0,2,2,0,1,0,0],[0,0,2,1,2,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,0,2,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,2,2,0,1],[0,0,2,0,2,1,0,2],[0,0,2,0,2,1,0,0],[0,0,2,0,2,0,0,1],[0,0,2,0,1,2,0,2],[0,0,2,0,1,2,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,0,0,2],[0,0,2,0,1,0,0,0],[0,0,2,0,0,2,0,1],[0,0,2,0,0,1,0,2],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,1,2,2,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,0,2,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,2,2,0,2],[0,0,1,0,2,2,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,0,0,2],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,2,0,2],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,2,2,2,1,0],[0,0,0,2,2,1,2,0],[0,0,0,2,2,1,0,0],[0,0,0,2,2,0,1,0],[0,0,0,2,1,2,2,0],[0,0,0,2,1,2,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,0,2,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,2,1,0],[0,0,0,2,0,1,2,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,1,2,2,2,0],[0,0,0,1,2,2,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,0,2,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,2,2,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,2,1,0],[0,0,0,0,2,2,0,1],[0,0,0,0,2,1,2,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,2,1],[0,0,0,0,2,0,1,2],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,2,2,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,0,2],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,2,2],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,2,1],[0,0,0,0,0,2,1,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,2,2],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]]], + "(2, 2, 2, -2)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,3,1,1,1,3,1,1,1,1,1,1,1,3,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,3,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,3,3,1,1,3,1,6],[[2,2,2,0,0,0,0,2],[2,2,1,0,0,0,0,1],[2,2,0,2,0,0,2,0],[2,2,0,1,0,0,1,0],[2,2,0,0,0,0,0,0],[2,1,2,0,0,0,0,1],[2,1,1,0,0,0,0,2],[2,1,1,0,0,0,0,0],[2,1,0,2,0,0,1,0],[2,1,0,1,0,0,2,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,2,0,2,0,0],[2,0,2,1,0,1,0,0],[2,0,2,0,0,0,0,0],[2,0,1,2,0,1,0,0],[2,0,1,1,0,2,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,0,0,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,2,2],[2,0,0,0,0,2,1,1],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,2,1],[2,0,0,0,0,1,1,2],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,2,2,0,0,0,0,1],[1,2,1,0,0,0,0,2],[1,2,1,0,0,0,0,0],[1,2,0,2,0,0,1,0],[1,2,0,1,0,0,2,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,2,0,0,0,0,2],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,2,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,2,2,0,1,0,0],[1,0,2,1,0,2,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,2,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,2,1],[1,0,0,0,0,2,1,2],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,2],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,2,2,2,2,0,0,0],[0,2,2,1,1,0,0,0],[0,2,2,0,0,0,0,0],[0,2,1,2,1,0,0,0],[0,2,1,1,2,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,0,0,0,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,2,2],[0,2,0,0,2,0,1,1],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,2,1],[0,2,0,0,1,0,1,2],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,2,2,1,0,0,0],[0,1,2,1,2,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,2,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,2,1],[0,1,0,0,2,0,1,2],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,2],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,2,2,0,0,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,2,0,2],[0,0,2,0,2,1,0,1],[0,0,2,0,2,0,0,0],[0,0,2,0,1,2,0,1],[0,0,2,0,1,1,0,2],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,2,0,1],[0,0,1,0,2,1,0,2],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,2],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,0,2,2,2,2,0],[0,0,0,2,2,1,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,2,1,0],[0,0,0,2,1,1,2,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,2,1,0],[0,0,0,1,2,1,2,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,2,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], "(2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,3,3,1,1,1,1,1,1,3,3,1,1,3,1,6,1,1,1,1,3,1,1,3,1,1,3,3,1,1,3,6,6,1,3,6,1,3,6,3,10,1,1,3,1,1,3,3,1,3,6,1,3,6,3,10,1,1,3,3,1,3,6,3,10,1,1,3,3,1,3,6,3,10,3,3,10,10,1,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,3,3,1,1,1,1,1,1,3,3,1,1,3,1,6,1,1,3,1,1,3,3,1,3,6,1,3,6,3,10,1,1,3,3,1,3,6,3,10,1,1,3,3,1,3,6,3,10,3,3,10,10,1,1,1,1,1,1,3,3,1,1,1,1,1,1,3,3,1,1,3,1,6,1,1,3,3,1,3,6,3,10,1,1,3,3,1,3,6,3,10,3,3,10,10,1,1,1,1,1,1,3,3,1,1,3,1,6,1,1,3,3,1,3,6,3,10,3,3,10,10,1,1,1,1,1,1,3,3,1,1,3,1,6,1,1,3,3,1,3,6,3,10,3,3,10,10,1,1,3,1,6,3,3,10,10,1,6,10,6,16],[[2,2,2,0,0,0,0,0],[2,2,1,1,0,0,0,0],[2,2,1,0,0,0,0,1],[2,2,0,2,0,0,0,0],[2,2,0,1,0,0,1,0],[2,2,0,0,0,0,2,0],[2,2,0,0,0,0,1,1],[2,2,0,0,0,0,0,2],[2,2,0,0,0,0,0,0],[2,1,2,1,0,0,0,0],[2,1,2,0,0,0,0,1],[2,1,1,2,0,0,0,0],[2,1,1,0,0,0,0,2],[2,1,1,0,0,0,0,0],[2,1,0,2,0,0,1,0],[2,1,0,1,0,0,2,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,2,1],[2,1,0,0,0,0,1,2],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,2,0,0,0,0],[2,0,2,1,0,1,0,0],[2,0,2,0,0,2,0,0],[2,0,2,0,0,1,0,1],[2,0,2,0,0,0,0,2],[2,0,2,0,0,0,0,0],[2,0,1,2,0,1,0,0],[2,0,1,1,0,2,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,2,0,1],[2,0,1,0,0,1,0,2],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,2,0,0],[2,0,0,2,0,1,1,0],[2,0,0,2,0,0,2,0],[2,0,0,2,0,0,0,0],[2,0,0,1,0,2,1,0],[2,0,0,1,0,1,2,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,2,0],[2,0,0,0,0,2,1,1],[2,0,0,0,0,2,0,2],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,2,1],[2,0,0,0,0,1,1,2],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,2],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,2,2,1,0,0,0,0],[1,2,2,0,0,0,0,1],[1,2,1,2,0,0,0,0],[1,2,1,0,0,0,0,2],[1,2,1,0,0,0,0,0],[1,2,0,2,0,0,1,0],[1,2,0,1,0,0,2,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,2,1],[1,2,0,0,0,0,1,2],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,2,2,0,0,0,0],[1,1,2,0,0,0,0,2],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,2,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,2],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,2,2,0,1,0,0],[1,0,2,1,0,2,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,2,0,1],[1,0,2,0,0,1,0,2],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,2,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,2],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,2,0,2,1,0],[1,0,0,2,0,1,2,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,2,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,2,1],[1,0,0,0,0,2,1,2],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,2],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,2,2,2,0,0,0,0],[0,2,2,1,1,0,0,0],[0,2,2,0,2,0,0,0],[0,2,2,0,1,0,0,1],[0,2,2,0,0,0,0,2],[0,2,2,0,0,0,0,0],[0,2,1,2,1,0,0,0],[0,2,1,1,2,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,2,0,0,1],[0,2,1,0,1,0,0,2],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,2,0,0,0],[0,2,0,2,1,0,1,0],[0,2,0,2,0,0,2,0],[0,2,0,2,0,0,0,0],[0,2,0,1,2,0,1,0],[0,2,0,1,1,0,2,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,2,0],[0,2,0,0,2,0,1,1],[0,2,0,0,2,0,0,2],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,2,1],[0,2,0,0,1,0,1,2],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,2],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,2,2,1,0,0,0],[0,1,2,1,2,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,2,0,0,1],[0,1,2,0,1,0,0,2],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,2,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,2],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,2,2,0,1,0],[0,1,0,2,1,0,2,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,2,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,2,1],[0,1,0,0,2,0,1,2],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,2],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,2,2,2,0,0,0],[0,0,2,2,1,1,0,0],[0,0,2,2,0,2,0,0],[0,0,2,2,0,0,0,0],[0,0,2,1,2,1,0,0],[0,0,2,1,1,2,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,2,0,0],[0,0,2,0,2,1,0,1],[0,0,2,0,2,0,0,2],[0,0,2,0,2,0,0,0],[0,0,2,0,1,2,0,1],[0,0,2,0,1,1,0,2],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,2],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,2,2,1,0,0],[0,0,1,2,1,2,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,2,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,2,0,1],[0,0,1,0,2,1,0,2],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,2],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,0,2,2,2,0,0],[0,0,0,2,2,1,1,0],[0,0,0,2,2,0,2,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,2,1,0],[0,0,0,2,1,1,2,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,2,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,2,1,0],[0,0,0,1,2,1,2,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,2,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,2,2,2,0],[0,0,0,0,2,2,1,1],[0,0,0,0,2,2,0,2],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,2,1],[0,0,0,0,2,1,1,2],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,2],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,2,1],[0,0,0,0,1,2,1,2],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,2],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,2,2,2],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], + "(2, 2, 2, 1)": [[1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1,3,1,3,1,1,1,1,1,3,1,1,3,3,1,1,3,1,1,1,1,1,3,1,3,3,1,3,1,6,1,1,6,3,3,6,6,1,1,1,1,3,1,3,1,1,6,3,3,6,6,1,1,3,1,3,3,3,6,6,1,1,1,3,1,1,6,6,1,3,6,3,10,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1,3,1,3,1,1,1,1,1,3,1,1,3,3,1,1,1,1,3,1,3,1,1,6,3,3,6,6,1,1,3,1,3,3,3,6,6,1,1,1,3,1,1,6,6,1,3,6,3,10,1,1,1,1,1,1,3,1,3,1,1,1,1,1,3,1,1,3,3,1,1,3,1,3,3,3,6,6,1,1,1,3,1,1,6,6,1,3,6,3,10,1,1,1,1,1,3,1,1,3,3,1,1,1,3,1,1,6,6,1,3,6,3,10,1,1,1,1,1,1,3,1,3,1,1,3,3,1,1,3,1,3,3,3,6,6,1,3,6,3,10,1,1,3,3,1,3,6,3,10,3,3,10,10],[[2,2,2,1,0,0,0,0],[2,2,1,2,0,0,0,0],[2,2,1,0,0,0,0,0],[2,2,0,1,0,0,0,0],[2,2,0,0,0,0,2,1],[2,2,0,0,0,0,1,2],[2,2,0,0,0,0,1,0],[2,2,0,0,0,0,0,1],[2,1,2,2,0,0,0,0],[2,1,2,0,0,0,0,0],[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,0,2,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,0,0,0,2,2],[2,1,0,0,0,0,2,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,0,2],[2,1,0,0,0,0,0,0],[2,0,2,1,0,0,0,0],[2,0,2,0,0,2,0,1],[2,0,2,0,0,1,0,2],[2,0,2,0,0,1,0,0],[2,0,2,0,0,0,0,1],[2,0,1,2,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,0,0,2,0,2],[2,0,1,0,0,2,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,0,0,2],[2,0,1,0,0,0,0,0],[2,0,0,2,0,2,1,0],[2,0,0,2,0,1,2,0],[2,0,0,2,0,1,0,0],[2,0,0,2,0,0,1,0],[2,0,0,1,0,2,2,0],[2,0,0,1,0,2,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,0,2,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,2,1,0],[2,0,0,0,0,2,0,1],[2,0,0,0,0,1,2,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,0,2],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,2,1],[2,0,0,0,0,0,1,2],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,2,2,2,0,0,0,0],[1,2,2,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,0,2,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,0,0,0,2,2],[1,2,0,0,0,0,2,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,0,2],[1,2,0,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,1,2,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,2,2,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,0,0,2,0,2],[1,0,2,0,0,2,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,0,0,2],[1,0,2,0,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,0,2,0,2,2,0],[1,0,0,2,0,2,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,0,2,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,2,2,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,0,2],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,2,2],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,2,2,1,0,0,0,0],[0,2,2,0,2,0,0,1],[0,2,2,0,1,0,0,2],[0,2,2,0,1,0,0,0],[0,2,2,0,0,0,0,1],[0,2,1,2,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,0,2,0,0,2],[0,2,1,0,2,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,2,2,0,1,0],[0,2,0,2,1,0,2,0],[0,2,0,2,1,0,0,0],[0,2,0,2,0,0,1,0],[0,2,0,1,2,0,2,0],[0,2,0,1,2,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,0,0,2,0],[0,2,0,1,0,0,0,0],[0,2,0,0,2,0,1,0],[0,2,0,0,2,0,0,1],[0,2,0,0,1,0,2,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,0,2],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,2,1],[0,2,0,0,0,0,1,2],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,2,2,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,0,2,0,0,2],[0,1,2,0,2,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,0,0,0,2],[0,1,2,0,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,0,2,2,0,2,0],[0,1,0,2,2,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,0,0,2,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,0,2,0,2,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,0,2],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,2,2],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,2,2,2,1,0,0],[0,0,2,2,1,2,0,0],[0,0,2,2,1,0,0,0],[0,0,2,2,0,1,0,0],[0,0,2,1,2,2,0,0],[0,0,2,1,2,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,0,2,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,2,1,0,0],[0,0,2,0,2,0,0,1],[0,0,2,0,1,2,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,0,0,2],[0,0,2,0,1,0,0,0],[0,0,2,0,0,2,0,1],[0,0,2,0,0,1,0,2],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,1,2,2,2,0,0],[0,0,1,2,2,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,0,2,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,2,2,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,0,0,2],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,2,0,2],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,2,2,1,0,0],[0,0,0,2,2,0,1,0],[0,0,0,2,1,2,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,0,2,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,2,1,0],[0,0,0,2,0,1,2,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,1,2,2,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,0,2,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,2,2,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,2,2,1],[0,0,0,0,2,2,1,2],[0,0,0,0,2,2,1,0],[0,0,0,0,2,2,0,1],[0,0,0,0,2,1,2,2],[0,0,0,0,2,1,2,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,2,1],[0,0,0,0,2,0,1,2],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,2,2,2],[0,0,0,0,1,2,2,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,0,2],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,2,2],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,2,1],[0,0,0,0,0,2,1,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,2,2],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]]], "(3, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,1,1,3,1,3],[[3,0,0,0,0,0,0,0],[2,1,0,0,0,0,0,0],[2,0,1,0,0,0,0,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,2,0,0,0,0,0,0],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,2,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,0,2,0,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,3,0,0,0,0,0,0],[0,2,1,0,0,0,0,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,2,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,0,2,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,3,0,0,0,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,1,2,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,2,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,3,0,0,0,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,3,0,0,0],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,3,0,0],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,3,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,3],[0,0,0,0,0,0,0,1]]], "(3, 1, 0, 0)": [[1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,1,2,2,1,2,1,6,1,2,2,2,2,2,3,3,2,3,2,3,2,8,1,2,2,2,2,3,2,3,2,8,1,2,2,2,3,2,8,1,2,2,2,3,2,8,1,2,2,8,1,8,1,1,1,1,1,1,2,2,2,1,2,2,1,2,2,1,2,1,6,1,2,2,2,2,3,2,3,2,8,1,2,2,2,3,2,8,1,2,2,2,3,2,8,1,2,2,8,1,8,1,1,1,1,1,2,2,1,2,2,1,2,1,6,1,2,2,2,3,2,8,1,2,2,2,3,2,8,1,2,2,8,1,8,1,1,1,1,2,2,1,2,1,6,1,2,2,2,3,2,8,1,2,2,8,1,8,1,1,1,1,2,2,1,2,1,6,1,2,2,2,3,2,8,1,2,2,8,1,8,1,1,1,2,1,6,1,2,2,8,1,8,1,1,6,1,8,6,15],[[3,1,0,0,0,0,0,0],[3,0,1,0,0,0,0,0],[3,0,0,1,0,0,0,0],[3,0,0,0,0,1,0,0],[3,0,0,0,0,0,1,0],[3,0,0,0,0,0,0,1],[2,2,0,0,0,0,0,0],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,0,0,0,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,0,0,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,3,0,0,0,0,0,0],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,3,0,0,0,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,3,0,0,0,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,3,0,0],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,3,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,3],[1,0,0,0,0,0,0,1],[0,3,1,0,0,0,0,0],[0,3,0,1,0,0,0,0],[0,3,0,0,1,0,0,0],[0,3,0,0,0,0,1,0],[0,3,0,0,0,0,0,1],[0,2,2,0,0,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,0,0,0,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,3,0,0,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,3,0,0,0,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,3,0,0,0],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,3,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,3],[0,1,0,0,0,0,0,1],[0,0,3,1,0,0,0,0],[0,0,3,0,1,0,0,0],[0,0,3,0,0,1,0,0],[0,0,3,0,0,0,0,1],[0,0,2,2,0,0,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,0,0,0],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,3,0,0,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,3,0,0,0],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,3,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,3],[0,0,1,0,0,0,0,1],[0,0,0,3,1,0,0,0],[0,0,0,3,0,1,0,0],[0,0,0,3,0,0,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,3,0,0,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,3,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,3,0],[0,0,0,1,0,0,1,0],[0,0,0,0,3,1,0,0],[0,0,0,0,3,0,1,0],[0,0,0,0,3,0,0,1],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,3,0,0],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,3,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,3],[0,0,0,0,1,0,0,1],[0,0,0,0,0,3,1,0],[0,0,0,0,0,3,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,3,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,3],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,3,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,3],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], + "(3, 1, 1, -1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,3,3,3,1,1,1,1,3,3,3,1,3,3,1,1,1,1,3,3,1,3,1,6,1,1,1,1,1,3,1,1,3,3,3,1,1,3,6,1,6,1,1,3,1,6,3,6,3,10,1,1,1,1,3,3,3,1,1,3,1,6,3,6,3,10,1,3,3,3,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,1,1,1,3,3,3,1,3,3,1,1,1,1,3,3,1,3,1,6,1,1,1,1,3,3,3,1,1,3,1,6,3,6,3,10,1,3,3,3,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,3,3,1,1,1,1,3,3,1,3,1,6,1,3,3,3,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,3,3,1,3,1,6,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,1,3,3,1,3,1,6,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,3,1,6,1,3,3,10,1,10,1,1,6,1,10,6,16],[[3,1,1,0,0,0,0,1],[3,1,0,1,0,0,1,0],[3,1,0,0,0,0,0,0],[3,0,1,1,0,1,0,0],[3,0,1,0,0,0,0,0],[3,0,0,1,0,0,0,0],[3,0,0,0,0,1,1,1],[3,0,0,0,0,1,0,0],[3,0,0,0,0,0,1,0],[3,0,0,0,0,0,0,1],[2,2,1,0,0,0,0,1],[2,2,0,1,0,0,1,0],[2,2,0,0,0,0,0,0],[2,1,2,0,0,0,0,1],[2,1,1,0,0,0,0,2],[2,1,1,0,0,0,0,0],[2,1,0,2,0,0,1,0],[2,1,0,1,0,0,2,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,1,0,1,0,0],[2,0,2,0,0,0,0,0],[2,0,1,2,0,1,0,0],[2,0,1,1,0,2,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,0,0,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,1,1],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,2,1],[2,0,0,0,0,1,1,2],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,3,1,0,0,0,0,1],[1,3,0,1,0,0,1,0],[1,3,0,0,0,0,0,0],[1,2,2,0,0,0,0,1],[1,2,1,0,0,0,0,2],[1,2,1,0,0,0,0,0],[1,2,0,2,0,0,1,0],[1,2,0,1,0,0,2,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,3,0,0,0,0,1],[1,1,2,0,0,0,0,2],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,3],[1,1,1,0,0,0,0,1],[1,1,0,3,0,0,1,0],[1,1,0,2,0,0,2,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,3,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,3,1,0,1,0,0],[1,0,3,0,0,0,0,0],[1,0,2,2,0,1,0,0],[1,0,2,1,0,2,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,3,0,1,0,0],[1,0,1,2,0,2,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,3,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,3,0,0,0,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,3,1,1],[1,0,0,0,0,3,0,0],[1,0,0,0,0,2,2,1],[1,0,0,0,0,2,1,2],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,3,1],[1,0,0,0,0,1,2,2],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,3],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,3,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,3],[1,0,0,0,0,0,0,1],[0,3,1,1,1,0,0,0],[0,3,1,0,0,0,0,0],[0,3,0,1,0,0,0,0],[0,3,0,0,1,0,1,1],[0,3,0,0,1,0,0,0],[0,3,0,0,0,0,1,0],[0,3,0,0,0,0,0,1],[0,2,2,1,1,0,0,0],[0,2,2,0,0,0,0,0],[0,2,1,2,1,0,0,0],[0,2,1,1,2,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,0,0,0,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,1,1],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,2,1],[0,2,0,0,1,0,1,2],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,3,1,1,0,0,0],[0,1,3,0,0,0,0,0],[0,1,2,2,1,0,0,0],[0,1,2,1,2,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,3,1,0,0,0],[0,1,1,2,2,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,3,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,3,0,0,0,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,3,0,1,1],[0,1,0,0,3,0,0,0],[0,1,0,0,2,0,2,1],[0,1,0,0,2,0,1,2],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,3,1],[0,1,0,0,1,0,2,2],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,3],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,3,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,3],[0,1,0,0,0,0,0,1],[0,0,3,1,0,0,0,0],[0,0,3,0,1,1,0,1],[0,0,3,0,1,0,0,0],[0,0,3,0,0,1,0,0],[0,0,3,0,0,0,0,1],[0,0,2,2,0,0,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,1,0,1],[0,0,2,0,2,0,0,0],[0,0,2,0,1,2,0,1],[0,0,2,0,1,1,0,2],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,3,0,0,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,3,1,0,1],[0,0,1,0,3,0,0,0],[0,0,1,0,2,2,0,1],[0,0,1,0,2,1,0,2],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,3,0,1],[0,0,1,0,1,2,0,2],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,3],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,3,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,3],[0,0,1,0,0,0,0,1],[0,0,0,3,1,1,1,0],[0,0,0,3,1,0,0,0],[0,0,0,3,0,1,0,0],[0,0,0,3,0,0,1,0],[0,0,0,2,2,1,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,2,1,0],[0,0,0,2,1,1,2,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,3,1,1,0],[0,0,0,1,3,0,0,0],[0,0,0,1,2,2,1,0],[0,0,0,1,2,1,2,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,3,1,0],[0,0,0,1,1,2,2,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,3,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,3,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,3,0],[0,0,0,1,0,0,1,0],[0,0,0,0,3,1,0,0],[0,0,0,0,3,0,1,0],[0,0,0,0,3,0,0,1],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,3,0,0],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,3,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,3],[0,0,0,0,1,0,0,1],[0,0,0,0,0,3,1,0],[0,0,0,0,0,3,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,3,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,3],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,3,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,3],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], "(3, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,3,1,3,1,3,1,7,1,1,1,1,3,1,3,1,7,1,1,1,3,1,7,1,1,1,3,1,7,1,1,7,7,1,1,1,1,1,3,3,1,3,1,3,1,7,1,3,3,3,3,12,1,3,3,12,1,3,3,12,1,12,1,1,1,1,3,1,3,1,7,1,3,3,12,1,3,3,12,1,12,1,1,1,3,1,7,1,3,3,12,1,12,1,1,1,3,1,7,1,3,3,12,1,12,1,1,7,1,12,7,21,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,1,7,1,1,1,3,1,7,1,1,1,3,1,7,1,1,7,7,1,1,1,1,3,1,3,1,7,1,3,3,12,1,3,3,12,1,12,1,1,1,3,1,7,1,3,3,12,1,12,1,1,1,3,1,7,1,3,3,12,1,12,1,1,7,1,12,7,21,1,1,1,1,1,3,1,1,1,3,1,7,1,1,1,3,1,7,1,1,7,7,1,1,1,3,1,7,1,3,3,12,1,12,1,1,1,3,1,7,1,3,3,12,1,12,1,1,7,1,12,7,21,1,1,1,3,1,1,1,3,1,7,1,1,7,7,1,1,1,3,1,7,1,3,3,12,1,12,1,1,7,1,12,7,21,1,1,1,3,1,1,1,3,1,7,1,1,7,7,1,1,1,3,1,7,1,3,3,12,1,12,1,1,7,1,12,7,21,1,3,1,1,7,7,1,1,7,1,12,7,21,3,7,7,21,3,21],[[3,1,1,0,0,0,0,0],[3,1,0,1,0,0,0,0],[3,1,0,0,0,0,1,0],[3,1,0,0,0,0,0,1],[3,0,1,1,0,0,0,0],[3,0,1,0,0,1,0,0],[3,0,1,0,0,0,0,1],[3,0,0,1,0,1,0,0],[3,0,0,1,0,0,1,0],[3,0,0,0,0,1,1,0],[3,0,0,0,0,1,0,1],[3,0,0,0,0,0,1,1],[3,0,0,0,0,0,0,0],[2,2,1,0,0,0,0,0],[2,2,0,1,0,0,0,0],[2,2,0,0,0,0,1,0],[2,2,0,0,0,0,0,1],[2,1,2,0,0,0,0,0],[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,0,2,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,0,0,0,2,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,0,2],[2,1,0,0,0,0,0,0],[2,0,2,1,0,0,0,0],[2,0,2,0,0,1,0,0],[2,0,2,0,0,0,0,1],[2,0,1,2,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,0,0,2,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,0,0,2],[2,0,1,0,0,0,0,0],[2,0,0,2,0,1,0,0],[2,0,0,2,0,0,1,0],[2,0,0,1,0,2,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,0,2,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,2,1,0],[2,0,0,0,0,2,0,1],[2,0,0,0,0,1,2,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,0,2],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,2,1],[2,0,0,0,0,0,1,2],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,3,1,0,0,0,0,0],[1,3,0,1,0,0,0,0],[1,3,0,0,0,0,1,0],[1,3,0,0,0,0,0,1],[1,2,2,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,0,2,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,0,0,0,2,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,0,2],[1,2,0,0,0,0,0,0],[1,1,3,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,1,2,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,0],[1,1,0,3,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,3,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,3],[1,1,0,0,0,0,0,1],[1,0,3,1,0,0,0,0],[1,0,3,0,0,1,0,0],[1,0,3,0,0,0,0,1],[1,0,2,2,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,0,0,2,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,0,0,2],[1,0,2,0,0,0,0,0],[1,0,1,3,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,3,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,3],[1,0,1,0,0,0,0,1],[1,0,0,3,0,1,0,0],[1,0,0,3,0,0,1,0],[1,0,0,2,0,2,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,0,2,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,3,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,3,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,3,1,0],[1,0,0,0,0,3,0,1],[1,0,0,0,0,2,2,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,0,2],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,3,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,3],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,3,1],[1,0,0,0,0,0,2,2],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,3],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,3,1,1,0,0,0,0],[0,3,1,0,1,0,0,0],[0,3,1,0,0,0,0,1],[0,3,0,1,1,0,0,0],[0,3,0,1,0,0,1,0],[0,3,0,0,1,0,1,0],[0,3,0,0,1,0,0,1],[0,3,0,0,0,0,1,1],[0,3,0,0,0,0,0,0],[0,2,2,1,0,0,0,0],[0,2,2,0,1,0,0,0],[0,2,2,0,0,0,0,1],[0,2,1,2,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,0,2,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,2,1,0,0,0],[0,2,0,2,0,0,1,0],[0,2,0,1,2,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,0,0,2,0],[0,2,0,1,0,0,0,0],[0,2,0,0,2,0,1,0],[0,2,0,0,2,0,0,1],[0,2,0,0,1,0,2,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,0,2],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,2,1],[0,2,0,0,0,0,1,2],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,3,1,0,0,0,0],[0,1,3,0,1,0,0,0],[0,1,3,0,0,0,0,1],[0,1,2,2,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,0,2,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,0,0,0,2],[0,1,2,0,0,0,0,0],[0,1,1,3,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,3,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,3],[0,1,1,0,0,0,0,1],[0,1,0,3,1,0,0,0],[0,1,0,3,0,0,1,0],[0,1,0,2,2,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,0,0,2,0],[0,1,0,2,0,0,0,0],[0,1,0,1,3,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,3,0],[0,1,0,1,0,0,1,0],[0,1,0,0,3,0,1,0],[0,1,0,0,3,0,0,1],[0,1,0,0,2,0,2,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,0,2],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,3,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,3],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,3,1],[0,1,0,0,0,0,2,2],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,3],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,3,1,1,0,0,0],[0,0,3,1,0,1,0,0],[0,0,3,0,1,1,0,0],[0,0,3,0,1,0,0,1],[0,0,3,0,0,1,0,1],[0,0,3,0,0,0,0,0],[0,0,2,2,1,0,0,0],[0,0,2,2,0,1,0,0],[0,0,2,1,2,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,0,2,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,2,1,0,0],[0,0,2,0,2,0,0,1],[0,0,2,0,1,2,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,0,0,2],[0,0,2,0,1,0,0,0],[0,0,2,0,0,2,0,1],[0,0,2,0,0,1,0,2],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,1,3,1,0,0,0],[0,0,1,3,0,1,0,0],[0,0,1,2,2,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,0,2,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,3,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,3,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,3,1,0,0],[0,0,1,0,3,0,0,1],[0,0,1,0,2,2,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,0,0,2],[0,0,1,0,2,0,0,0],[0,0,1,0,1,3,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,3],[0,0,1,0,1,0,0,1],[0,0,1,0,0,3,0,1],[0,0,1,0,0,2,0,2],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,3],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,3,1,1,0,0],[0,0,0,3,1,0,1,0],[0,0,0,3,0,1,1,0],[0,0,0,3,0,0,0,0],[0,0,0,2,2,1,0,0],[0,0,0,2,2,0,1,0],[0,0,0,2,1,2,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,0,2,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,2,1,0],[0,0,0,2,0,1,2,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,1,3,1,0,0],[0,0,0,1,3,0,1,0],[0,0,0,1,2,2,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,0,2,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,3,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,3,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,3,1,0],[0,0,0,1,0,2,2,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,3,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,3,1,1,0],[0,0,0,0,3,1,0,1],[0,0,0,0,3,0,1,1],[0,0,0,0,3,0,0,0],[0,0,0,0,2,2,1,0],[0,0,0,0,2,2,0,1],[0,0,0,0,2,1,2,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,2,1],[0,0,0,0,2,0,1,2],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,3,1,0],[0,0,0,0,1,3,0,1],[0,0,0,0,1,2,2,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,0,2],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,3,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,3],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,3,1],[0,0,0,0,1,0,2,2],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,3],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,3,1,1],[0,0,0,0,0,3,0,0],[0,0,0,0,0,2,2,1],[0,0,0,0,0,2,1,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,3,1],[0,0,0,0,0,1,2,2],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,3],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,3,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,3],[0,0,0,0,0,0,0,1]]], - "(3, 1, 1, 1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,3,1,1,3,1,1,3,3,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,1,1,1,3,3,1,1,3,3,1,1,3,1,6,6,3,6,1,1,3,1,6,3,10,1,1,3,1,1,3,3,3,6,1,1,3,1,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,3,1,1,3,3,3,6,1,1,3,1,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,3,3,1,3,1,6,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,3,3,1,3,1,6,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,3,1,6,1,3,3,10,1,10,1,1,6,1,10,6,16],[[3,1,1,1,0,0,0,0],[3,1,0,0,0,0,1,1],[3,1,0,0,0,0,0,0],[3,0,1,0,0,1,0,1],[3,0,1,0,0,0,0,0],[3,0,0,1,0,1,1,0],[3,0,0,1,0,0,0,0],[3,0,0,0,0,1,0,0],[3,0,0,0,0,0,1,0],[3,0,0,0,0,0,0,1],[2,2,1,1,0,0,0,0],[2,2,0,0,0,0,1,1],[2,2,0,0,0,0,0,0],[2,1,2,1,0,0,0,0],[2,1,1,2,0,0,0,0],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,2,1],[2,1,0,0,0,0,1,2],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,0,0,1,0,1],[2,0,2,0,0,0,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,2,0,1],[2,0,1,0,0,1,0,2],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,1,1,0],[2,0,0,2,0,0,0,0],[2,0,0,1,0,2,1,0],[2,0,0,1,0,1,2,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,3,1,1,0,0,0,0],[1,3,0,0,0,0,1,1],[1,3,0,0,0,0,0,0],[1,2,2,1,0,0,0,0],[1,2,1,2,0,0,0,0],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,2,1],[1,2,0,0,0,0,1,2],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,3,1,0,0,0,0],[1,1,2,2,0,0,0,0],[1,1,2,0,0,0,0,0],[1,1,1,3,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,3,1],[1,1,0,0,0,0,2,2],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,3],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,3,0,0,1,0,1],[1,0,3,0,0,0,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,2,0,1],[1,0,2,0,0,1,0,2],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,3,0,1],[1,0,1,0,0,2,0,2],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,3],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,3,0,1,1,0],[1,0,0,3,0,0,0,0],[1,0,0,2,0,2,1,0],[1,0,0,2,0,1,2,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,3,1,0],[1,0,0,1,0,2,2,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,3,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,3,0,0],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,3,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,3],[1,0,0,0,0,0,0,1],[0,3,1,0,1,0,0,1],[0,3,1,0,0,0,0,0],[0,3,0,1,1,0,1,0],[0,3,0,1,0,0,0,0],[0,3,0,0,1,0,0,0],[0,3,0,0,0,0,1,0],[0,3,0,0,0,0,0,1],[0,2,2,0,1,0,0,1],[0,2,2,0,0,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,2,0,0,1],[0,2,1,0,1,0,0,2],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,1,0,1,0],[0,2,0,2,0,0,0,0],[0,2,0,1,2,0,1,0],[0,2,0,1,1,0,2,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,3,0,1,0,0,1],[0,1,3,0,0,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,2,0,0,1],[0,1,2,0,1,0,0,2],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,3,0,0,1],[0,1,1,0,2,0,0,2],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,3],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,3,1,0,1,0],[0,1,0,3,0,0,0,0],[0,1,0,2,2,0,1,0],[0,1,0,2,1,0,2,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,3,0,1,0],[0,1,0,1,2,0,2,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,3,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,3,0,0,0],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,3,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,3],[0,1,0,0,0,0,0,1],[0,0,3,1,1,1,0,0],[0,0,3,1,0,0,0,0],[0,0,3,0,1,0,0,0],[0,0,3,0,0,1,0,0],[0,0,3,0,0,0,0,1],[0,0,2,2,1,1,0,0],[0,0,2,2,0,0,0,0],[0,0,2,1,2,1,0,0],[0,0,2,1,1,2,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,0,0,0],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,3,1,1,0,0],[0,0,1,3,0,0,0,0],[0,0,1,2,2,1,0,0],[0,0,1,2,1,2,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,3,1,0,0],[0,0,1,1,2,2,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,3,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,3,0,0,0],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,3,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,3],[0,0,1,0,0,0,0,1],[0,0,0,3,1,0,0,0],[0,0,0,3,0,1,0,0],[0,0,0,3,0,0,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,3,0,0,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,3,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,3,0],[0,0,0,1,0,0,1,0],[0,0,0,0,3,1,1,1],[0,0,0,0,3,1,0,0],[0,0,0,0,3,0,1,0],[0,0,0,0,3,0,0,1],[0,0,0,0,2,2,1,1],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,2,1],[0,0,0,0,2,1,1,2],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,3,1,1],[0,0,0,0,1,3,0,0],[0,0,0,0,1,2,2,1],[0,0,0,0,1,2,1,2],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,3,1],[0,0,0,0,1,1,2,2],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,3],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,3,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,3],[0,0,0,0,1,0,0,1],[0,0,0,0,0,3,1,0],[0,0,0,0,0,3,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,3,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,3],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,3,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,3],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]] + "(3, 1, 1, 1)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,3,1,1,3,1,1,3,3,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,1,1,1,3,3,1,1,3,3,1,1,3,1,6,6,3,6,1,1,3,1,6,3,10,1,1,3,1,1,3,3,3,6,1,1,3,1,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,3,1,1,3,3,3,6,1,1,3,1,6,3,10,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,1,3,3,1,3,3,1,3,1,6,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,3,3,1,3,1,6,1,3,3,3,6,3,10,1,3,3,10,1,10,1,1,1,1,1,1,1,1,3,3,1,3,1,6,1,1,1,1,3,3,1,1,3,1,6,3,10,1,3,3,10,1,10,1,1,1,3,1,6,1,3,3,10,1,10,1,1,6,1,10,6,16],[[3,1,1,1,0,0,0,0],[3,1,0,0,0,0,1,1],[3,1,0,0,0,0,0,0],[3,0,1,0,0,1,0,1],[3,0,1,0,0,0,0,0],[3,0,0,1,0,1,1,0],[3,0,0,1,0,0,0,0],[3,0,0,0,0,1,0,0],[3,0,0,0,0,0,1,0],[3,0,0,0,0,0,0,1],[2,2,1,1,0,0,0,0],[2,2,0,0,0,0,1,1],[2,2,0,0,0,0,0,0],[2,1,2,1,0,0,0,0],[2,1,1,2,0,0,0,0],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,2,1],[2,1,0,0,0,0,1,2],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,0,2,0,0,1,0,1],[2,0,2,0,0,0,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,2,0,1],[2,0,1,0,0,1,0,2],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,0,2,0,1,1,0],[2,0,0,2,0,0,0,0],[2,0,0,1,0,2,1,0],[2,0,0,1,0,1,2,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,0,0,2,0,0],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,0,2,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,0,2],[2,0,0,0,0,0,0,0],[1,3,1,1,0,0,0,0],[1,3,0,0,0,0,1,1],[1,3,0,0,0,0,0,0],[1,2,2,1,0,0,0,0],[1,2,1,2,0,0,0,0],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,2,1],[1,2,0,0,0,0,1,2],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,1,3,1,0,0,0,0],[1,1,2,2,0,0,0,0],[1,1,2,0,0,0,0,0],[1,1,1,3,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,0,0,0,3,1],[1,1,0,0,0,0,2,2],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,3],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,0],[1,0,3,0,0,1,0,1],[1,0,3,0,0,0,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,2,0,1],[1,0,2,0,0,1,0,2],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,0,0,3,0,1],[1,0,1,0,0,2,0,2],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,3],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,0],[1,0,0,3,0,1,1,0],[1,0,0,3,0,0,0,0],[1,0,0,2,0,2,1,0],[1,0,0,2,0,1,2,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,1,0,3,1,0],[1,0,0,1,0,2,2,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,3,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,3,0,0],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,3,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,3],[1,0,0,0,0,0,0,1],[0,3,1,0,1,0,0,1],[0,3,1,0,0,0,0,0],[0,3,0,1,1,0,1,0],[0,3,0,1,0,0,0,0],[0,3,0,0,1,0,0,0],[0,3,0,0,0,0,1,0],[0,3,0,0,0,0,0,1],[0,2,2,0,1,0,0,1],[0,2,2,0,0,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,2,0,0,1],[0,2,1,0,1,0,0,2],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,0,2,1,0,1,0],[0,2,0,2,0,0,0,0],[0,2,0,1,2,0,1,0],[0,2,0,1,1,0,2,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,0,2,0,0,0],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,0,0,2,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,0,2],[0,2,0,0,0,0,0,0],[0,1,3,0,1,0,0,1],[0,1,3,0,0,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,2,0,0,1],[0,1,2,0,1,0,0,2],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,0,3,0,0,1],[0,1,1,0,2,0,0,2],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,3],[0,1,1,0,1,0,0,1],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,0],[0,1,0,3,1,0,1,0],[0,1,0,3,0,0,0,0],[0,1,0,2,2,0,1,0],[0,1,0,2,1,0,2,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,1,3,0,1,0],[0,1,0,1,2,0,2,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,3,0],[0,1,0,1,1,0,1,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,0,0],[0,1,0,0,3,0,0,0],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,3,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,3],[0,1,0,0,0,0,0,1],[0,0,3,1,1,1,0,0],[0,0,3,1,0,0,0,0],[0,0,3,0,1,0,0,0],[0,0,3,0,0,1,0,0],[0,0,3,0,0,0,0,1],[0,0,2,2,1,1,0,0],[0,0,2,2,0,0,0,0],[0,0,2,1,2,1,0,0],[0,0,2,1,1,2,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,0,2,0,0,0],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,0,2,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,0,0,2],[0,0,2,0,0,0,0,0],[0,0,1,3,1,1,0,0],[0,0,1,3,0,0,0,0],[0,0,1,2,2,1,0,0],[0,0,1,2,1,2,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,1,3,1,0,0],[0,0,1,1,2,2,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,3,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,3,0,0,0],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,0],[0,0,1,0,0,3,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,3],[0,0,1,0,0,0,0,1],[0,0,0,3,1,0,0,0],[0,0,0,3,0,1,0,0],[0,0,0,3,0,0,1,0],[0,0,0,2,2,0,0,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,0,2,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,0,2,0],[0,0,0,2,0,0,0,0],[0,0,0,1,3,0,0,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,3,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,3,0],[0,0,0,1,0,0,1,0],[0,0,0,0,3,1,1,1],[0,0,0,0,3,1,0,0],[0,0,0,0,3,0,1,0],[0,0,0,0,3,0,0,1],[0,0,0,0,2,2,1,1],[0,0,0,0,2,2,0,0],[0,0,0,0,2,1,2,1],[0,0,0,0,2,1,1,2],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,0,2,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,0,2],[0,0,0,0,2,0,0,0],[0,0,0,0,1,3,1,1],[0,0,0,0,1,3,0,0],[0,0,0,0,1,2,2,1],[0,0,0,0,1,2,1,2],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,1,3,1],[0,0,0,0,1,1,2,2],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,3],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,3,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,3],[0,0,0,0,1,0,0,1],[0,0,0,0,0,3,1,0],[0,0,0,0,0,3,0,1],[0,0,0,0,0,2,2,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,0,2],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,3,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,3],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,3,1],[0,0,0,0,0,0,2,2],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,3],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,0]]], + "(3, 2, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,2,3,3,2,3,2,3,2,7,1,2,2,2,2,3,2,3,2,7,1,2,2,2,3,2,7,1,2,2,2,3,2,7,1,2,2,7,1,7,1,1,1,1,2,3,3,2,3,2,3,2,7,1,3,3,3,3,11,1,3,3,11,1,3,3,11,1,11,1,1,1,2,3,2,3,2,7,1,3,3,11,1,3,3,11,1,11,1,1,2,3,2,7,1,3,3,11,1,11,1,1,2,3,2,7,1,3,3,11,1,11,1,2,7,1,11,7,21,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,3,2,3,2,7,1,2,2,2,3,2,7,1,2,2,2,3,2,7,1,2,2,7,1,7,1,1,1,2,3,2,3,2,7,1,3,3,11,1,3,3,11,1,11,1,1,2,3,2,7,1,3,3,11,1,11,1,1,2,3,2,7,1,3,3,11,1,11,1,2,7,1,11,7,21,1,1,1,1,1,1,1,1,1,2,1,2,2,2,3,2,7,1,2,2,2,3,2,7,1,2,2,7,1,7,1,1,2,3,2,7,1,3,3,11,1,11,1,1,2,3,2,7,1,3,3,11,1,11,1,2,7,1,11,7,21,1,1,1,1,1,1,2,1,2,2,2,3,2,7,1,2,2,7,1,7,1,1,2,3,2,7,1,3,3,11,1,11,1,2,7,1,11,7,21,1,1,1,1,1,1,2,1,2,2,2,3,2,7,1,2,2,7,1,7,1,1,2,3,2,7,1,3,3,11,1,11,1,2,7,1,11,7,21,1,1,1,2,1,2,2,7,1,7,1,2,7,1,11,7,21,1,2,1,7,7,21,2,21],[[3,2,0,0,0,0,0,0],[3,1,1,0,0,0,0,0],[3,1,0,1,0,0,0,0],[3,1,0,0,0,0,1,0],[3,1,0,0,0,0,0,1],[3,0,2,0,0,0,0,0],[3,0,1,1,0,0,0,0],[3,0,1,0,0,1,0,0],[3,0,1,0,0,0,0,1],[3,0,0,2,0,0,0,0],[3,0,0,1,0,1,0,0],[3,0,0,1,0,0,1,0],[3,0,0,0,0,2,0,0],[3,0,0,0,0,1,1,0],[3,0,0,0,0,1,0,1],[3,0,0,0,0,0,2,0],[3,0,0,0,0,0,1,1],[3,0,0,0,0,0,0,2],[3,0,0,0,0,0,0,0],[2,3,0,0,0,0,0,0],[2,2,1,0,0,0,0,0],[2,2,0,1,0,0,0,0],[2,2,0,0,0,0,1,0],[2,2,0,0,0,0,0,1],[2,1,2,0,0,0,0,0],[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,0,2,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,0,0,0,2,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,0,2],[2,1,0,0,0,0,0,0],[2,0,3,0,0,0,0,0],[2,0,2,1,0,0,0,0],[2,0,2,0,0,1,0,0],[2,0,2,0,0,0,0,1],[2,0,1,2,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,0,0,2,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,0,0,2],[2,0,1,0,0,0,0,0],[2,0,0,3,0,0,0,0],[2,0,0,2,0,1,0,0],[2,0,0,2,0,0,1,0],[2,0,0,1,0,2,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,0,2,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,3,0,0],[2,0,0,0,0,2,1,0],[2,0,0,0,0,2,0,1],[2,0,0,0,0,1,2,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,0,2],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,3,0],[2,0,0,0,0,0,2,1],[2,0,0,0,0,0,1,2],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,3],[2,0,0,0,0,0,0,1],[1,3,1,0,0,0,0,0],[1,3,0,1,0,0,0,0],[1,3,0,0,0,0,1,0],[1,3,0,0,0,0,0,1],[1,2,2,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,0,2,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,0,0,0,2,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,0,2],[1,2,0,0,0,0,0,0],[1,1,3,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,1,2,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,0],[1,1,0,3,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,3,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,3],[1,1,0,0,0,0,0,1],[1,0,3,1,0,0,0,0],[1,0,3,0,0,1,0,0],[1,0,3,0,0,0,0,1],[1,0,2,2,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,0,0,2,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,0,0,2],[1,0,2,0,0,0,0,0],[1,0,1,3,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,3,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,3],[1,0,1,0,0,0,0,1],[1,0,0,3,0,1,0,0],[1,0,0,3,0,0,1,0],[1,0,0,2,0,2,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,0,2,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,3,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,3,0],[1,0,0,1,0,0,1,0],[1,0,0,0,0,3,1,0],[1,0,0,0,0,3,0,1],[1,0,0,0,0,2,2,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,0,2],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,3,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,3],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,3,1],[1,0,0,0,0,0,2,2],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,3],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,0],[0,3,2,0,0,0,0,0],[0,3,1,1,0,0,0,0],[0,3,1,0,1,0,0,0],[0,3,1,0,0,0,0,1],[0,3,0,2,0,0,0,0],[0,3,0,1,1,0,0,0],[0,3,0,1,0,0,1,0],[0,3,0,0,2,0,0,0],[0,3,0,0,1,0,1,0],[0,3,0,0,1,0,0,1],[0,3,0,0,0,0,2,0],[0,3,0,0,0,0,1,1],[0,3,0,0,0,0,0,2],[0,3,0,0,0,0,0,0],[0,2,3,0,0,0,0,0],[0,2,2,1,0,0,0,0],[0,2,2,0,1,0,0,0],[0,2,2,0,0,0,0,1],[0,2,1,2,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,0,2,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,3,0,0,0,0],[0,2,0,2,1,0,0,0],[0,2,0,2,0,0,1,0],[0,2,0,1,2,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,0,0,2,0],[0,2,0,1,0,0,0,0],[0,2,0,0,3,0,0,0],[0,2,0,0,2,0,1,0],[0,2,0,0,2,0,0,1],[0,2,0,0,1,0,2,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,0,2],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,3,0],[0,2,0,0,0,0,2,1],[0,2,0,0,0,0,1,2],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,3],[0,2,0,0,0,0,0,1],[0,1,3,1,0,0,0,0],[0,1,3,0,1,0,0,0],[0,1,3,0,0,0,0,1],[0,1,2,2,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,0,2,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,0,0,0,2],[0,1,2,0,0,0,0,0],[0,1,1,3,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,3,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,3],[0,1,1,0,0,0,0,1],[0,1,0,3,1,0,0,0],[0,1,0,3,0,0,1,0],[0,1,0,2,2,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,0,0,2,0],[0,1,0,2,0,0,0,0],[0,1,0,1,3,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,3,0],[0,1,0,1,0,0,1,0],[0,1,0,0,3,0,1,0],[0,1,0,0,3,0,0,1],[0,1,0,0,2,0,2,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,0,2],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,3,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,3],[0,1,0,0,1,0,0,1],[0,1,0,0,0,0,3,1],[0,1,0,0,0,0,2,2],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,3],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,0],[0,0,3,2,0,0,0,0],[0,0,3,1,1,0,0,0],[0,0,3,1,0,1,0,0],[0,0,3,0,2,0,0,0],[0,0,3,0,1,1,0,0],[0,0,3,0,1,0,0,1],[0,0,3,0,0,2,0,0],[0,0,3,0,0,1,0,1],[0,0,3,0,0,0,0,2],[0,0,3,0,0,0,0,0],[0,0,2,3,0,0,0,0],[0,0,2,2,1,0,0,0],[0,0,2,2,0,1,0,0],[0,0,2,1,2,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,0,2,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,3,0,0,0],[0,0,2,0,2,1,0,0],[0,0,2,0,2,0,0,1],[0,0,2,0,1,2,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,0,0,2],[0,0,2,0,1,0,0,0],[0,0,2,0,0,3,0,0],[0,0,2,0,0,2,0,1],[0,0,2,0,0,1,0,2],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,3],[0,0,2,0,0,0,0,1],[0,0,1,3,1,0,0,0],[0,0,1,3,0,1,0,0],[0,0,1,2,2,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,0,2,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,3,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,3,0,0],[0,0,1,1,0,1,0,0],[0,0,1,0,3,1,0,0],[0,0,1,0,3,0,0,1],[0,0,1,0,2,2,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,0,0,2],[0,0,1,0,2,0,0,0],[0,0,1,0,1,3,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,3],[0,0,1,0,1,0,0,1],[0,0,1,0,0,3,0,1],[0,0,1,0,0,2,0,2],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,3],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,0],[0,0,0,3,2,0,0,0],[0,0,0,3,1,1,0,0],[0,0,0,3,1,0,1,0],[0,0,0,3,0,2,0,0],[0,0,0,3,0,1,1,0],[0,0,0,3,0,0,2,0],[0,0,0,3,0,0,0,0],[0,0,0,2,3,0,0,0],[0,0,0,2,2,1,0,0],[0,0,0,2,2,0,1,0],[0,0,0,2,1,2,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,0,2,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,3,0,0],[0,0,0,2,0,2,1,0],[0,0,0,2,0,1,2,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,3,0],[0,0,0,2,0,0,1,0],[0,0,0,1,3,1,0,0],[0,0,0,1,3,0,1,0],[0,0,0,1,2,2,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,0,2,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,3,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,3,0],[0,0,0,1,1,0,1,0],[0,0,0,1,0,3,1,0],[0,0,0,1,0,2,2,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,3,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,0,0],[0,0,0,0,3,2,0,0],[0,0,0,0,3,1,1,0],[0,0,0,0,3,1,0,1],[0,0,0,0,3,0,2,0],[0,0,0,0,3,0,1,1],[0,0,0,0,3,0,0,2],[0,0,0,0,3,0,0,0],[0,0,0,0,2,3,0,0],[0,0,0,0,2,2,1,0],[0,0,0,0,2,2,0,1],[0,0,0,0,2,1,2,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,3,0],[0,0,0,0,2,0,2,1],[0,0,0,0,2,0,1,2],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,3],[0,0,0,0,2,0,0,1],[0,0,0,0,1,3,1,0],[0,0,0,0,1,3,0,1],[0,0,0,0,1,2,2,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,0,2],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,3,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,3],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,3,1],[0,0,0,0,1,0,2,2],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,3],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,0],[0,0,0,0,0,3,2,0],[0,0,0,0,0,3,1,1],[0,0,0,0,0,3,0,2],[0,0,0,0,0,3,0,0],[0,0,0,0,0,2,3,0],[0,0,0,0,0,2,2,1],[0,0,0,0,0,2,1,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,3],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,3,1],[0,0,0,0,0,1,2,2],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,3],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,3,2],[0,0,0,0,0,0,3,0],[0,0,0,0,0,0,2,3],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,3],[0,0,0,0,0,0,0,1]]] }, - "SU(2)": { - "(0, 0)": [[1],[[0,0]]], - "(1, 0)": [[1,1],[[1,0],[0,1]]], - "(10, 0)": [[1,1,1,1,1,1,1,1,1,1,1],[[10,0],[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9],[0,10]]], - "(11, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1],[[11,0],[10,1],[9,2],[8,3],[7,4],[6,5],[5,6],[4,7],[3,8],[2,9],[1,10],[0,11]]], - "(12, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1],[[12,0],[11,1],[10,2],[9,3],[8,4],[7,5],[6,6],[5,7],[4,8],[3,9],[2,10],[1,11],[0,12]]], - "(13, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[13,0],[12,1],[11,2],[10,3],[9,4],[8,5],[7,6],[6,7],[5,8],[4,9],[3,10],[2,11],[1,12],[0,13]]], - "(14, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[14,0],[13,1],[12,2],[11,3],[10,4],[9,5],[8,6],[7,7],[6,8],[5,9],[4,10],[3,11],[2,12],[1,13],[0,14]]], - "(15, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[15,0],[14,1],[13,2],[12,3],[11,4],[10,5],[9,6],[8,7],[7,8],[6,9],[5,10],[4,11],[3,12],[2,13],[1,14],[0,15]]], - "(16, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[16,0],[15,1],[14,2],[13,3],[12,4],[11,5],[10,6],[9,7],[8,8],[7,9],[6,10],[5,11],[4,12],[3,13],[2,14],[1,15],[0,16]]], - "(17, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[17,0],[16,1],[15,2],[14,3],[13,4],[12,5],[11,6],[10,7],[9,8],[8,9],[7,10],[6,11],[5,12],[4,13],[3,14],[2,15],[1,16],[0,17]]], - "(18, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[18,0],[17,1],[16,2],[15,3],[14,4],[13,5],[12,6],[11,7],[10,8],[9,9],[8,10],[7,11],[6,12],[5,13],[4,14],[3,15],[2,16],[1,17],[0,18]]], - "(19, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[19,0],[18,1],[17,2],[16,3],[15,4],[14,5],[13,6],[12,7],[11,8],[10,9],[9,10],[8,11],[7,12],[6,13],[5,14],[4,15],[3,16],[2,17],[1,18],[0,19]]], - "(2, 0)": [[1,1,1],[[2,0],[1,1],[0,2]]], - "(3, 0)": [[1,1,1,1],[[3,0],[2,1],[1,2],[0,3]]], - "(4, 0)": [[1,1,1,1,1],[[4,0],[3,1],[2,2],[1,3],[0,4]]], - "(5, 0)": [[1,1,1,1,1,1],[[5,0],[4,1],[3,2],[2,3],[1,4],[0,5]]], - "(6, 0)": [[1,1,1,1,1,1,1],[[6,0],[5,1],[4,2],[3,3],[2,4],[1,5],[0,6]]], - "(7, 0)": [[1,1,1,1,1,1,1,1],[[7,0],[6,1],[5,2],[4,3],[3,4],[2,5],[1,6],[0,7]]], - "(8, 0)": [[1,1,1,1,1,1,1,1,1],[[8,0],[7,1],[6,2],[5,3],[4,4],[3,5],[2,6],[1,7],[0,8]]], - "(9, 0)": [[1,1,1,1,1,1,1,1,1,1],[[9,0],[8,1],[7,2],[6,3],[5,4],[4,5],[3,6],[2,7],[1,8],[0,9]]] + "SO(9)": { + "(0, 0, 0, 0)": [[1],[[0,0,0,0,0,0,0,0]]], + "(1, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1],[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4],[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,1,1,3,1,3,3,4],[[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(1, 1, 1, 1)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,2,1,2,2,3,1,1,1,2,1,2,2,3,1,2,2,3,2,3,3,6],[[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(2, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4],[[2,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(2, 1, 0, 0)": [[1,1,1,1,1,1,1,1,2,2,2,2,2,1,2,2,2,2,1,2,2,2,1,2,2,2,1,2,2,1,2,7,1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,2,1,2,2,1,2,7,1,1,1,1,1,1,2,2,2,1,2,2,2,1,2,2,1,2,7,1,1,1,1,1,2,2,2,1,2,2,1,2,7,1,1,1,1,1,2,2,2,1,2,2,1,2,7,1,1,1,1,2,2,1,2,7,1,1,1,2,7,1,7,7],[[2,1,0,0,0,0,0,0],[2,0,1,0,0,0,0,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,0,0,0,0,0,0],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,2,1,0,0,0,0,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(2, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,3,3,3,1,3,3,1,3,3,1,3,8,1,1,1,1,1,3,3,1,3,3,1,3,8,1,1,1,1,3,3,1,3,8,1,1,1,1,3,3,1,3,8,1,1,1,3,8,1,8,9,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,3,3,1,3,3,1,3,8,1,1,1,1,3,3,1,3,8,1,1,1,1,3,3,1,3,8,1,1,1,3,8,1,8,9,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,3,1,3,8,1,1,1,1,3,3,1,3,8,1,1,1,3,8,1,8,9,1,1,1,1,1,1,3,1,1,1,1,3,3,1,3,8,1,1,1,3,8,1,8,9,1,1,1,1,1,1,3,1,1,1,1,3,3,1,3,8,1,1,1,3,8,1,8,9,1,1,1,3,1,1,1,3,8,1,8,9,1,3,1,8,9,3,9,18],[[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,1,0,0,0,0,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,1,0,0,0,0,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,2,0,0,0,0,0,0],[1,1,2,0,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,1],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,1,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,2,0,0,0,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,1,0,0,0,0,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,2,0,0,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(2, 1, 1, 1)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,1,1,1,1,1,2,1,1,1,1,4,1,4,7,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,1,1,2,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,1,1,2,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,2,2,3,1,2,1,7,9,2,9,15,2,3,2,9,15,3,15,20],[[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,1,0,0,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,1,0,0,0,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,2,0,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,2,0,0,0,0,0],[1,1,1,2,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,1],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,1,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,2,0,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,1,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,1],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,1,0,0,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,2,0,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,1],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,1,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,1],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], + "(3, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,4,1,1,4,4],[[3,0,0,0,0,0,0,0],[2,1,0,0,0,0,0,0],[2,0,1,0,0,0,0,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,0,0,0,0,0,0],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,3,0,0,0,0,0,0],[0,2,1,0,0,0,0,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,3,0,0,0,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,3,0,0,0,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,3,0,0,0],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,3,0,0],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,3,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,3],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]] }, "SU(3)": { "(0, 0, 0)": [[1],[[0,0,0]]], @@ -173,7 +193,12 @@ "(5, 1, 0)": [[1,1,1,2,1,1,2,2,1,1,2,2,2,1,1,2,2,2,2,1,1,1,1,1,1],[[5,1,0],[5,0,1],[4,2,0],[4,1,1],[4,0,2],[3,3,0],[3,2,1],[3,1,2],[3,0,3],[2,4,0],[2,3,1],[2,2,2],[2,1,3],[2,0,4],[1,5,0],[1,4,1],[1,3,2],[1,2,3],[1,1,4],[1,0,5],[0,5,1],[0,4,2],[0,3,3],[0,2,4],[0,1,5]]], "(5, 2, 0)": [[1,1,1,1,2,2,1,1,2,3,2,1,1,2,3,3,2,1,1,2,2,2,1,1,1,1,1],[[5,2,0],[5,1,1],[5,0,2],[4,3,0],[4,2,1],[4,1,2],[4,0,3],[3,4,0],[3,3,1],[3,2,2],[3,1,3],[3,0,4],[2,5,0],[2,4,1],[2,3,2],[2,2,3],[2,1,4],[2,0,5],[1,5,1],[1,4,2],[1,3,3],[1,2,4],[1,1,5],[0,5,2],[0,4,3],[0,3,4],[0,2,5]]], "(5, 3, 0)": [[1,1,1,1,1,2,2,2,1,1,2,3,3,2,1,1,2,3,2,1,1,2,2,1,1,1,1],[[5,3,0],[5,2,1],[5,1,2],[5,0,3],[4,4,0],[4,3,1],[4,2,2],[4,1,3],[4,0,4],[3,5,0],[3,4,1],[3,3,2],[3,2,3],[3,1,4],[3,0,5],[2,5,1],[2,4,2],[2,3,3],[2,2,4],[2,1,5],[1,5,2],[1,4,3],[1,3,4],[1,2,5],[0,5,3],[0,4,4],[0,3,5]]], - "(5, 4, 0)": [[1,1,1,1,1,1,2,2,2,2,1,1,2,2,2,1,1,2,2,1,1,2,1,1,1],[[5,4,0],[5,3,1],[5,2,2],[5,1,3],[5,0,4],[4,5,0],[4,4,1],[4,3,2],[4,2,3],[4,1,4],[4,0,5],[3,5,1],[3,4,2],[3,3,3],[3,2,4],[3,1,5],[2,5,2],[2,4,3],[2,3,4],[2,2,5],[1,5,3],[1,4,4],[1,3,5],[0,5,4],[0,4,5]]] + "(5, 4, 0)": [[1,1,1,1,1,1,2,2,2,2,1,1,2,2,2,1,1,2,2,1,1,2,1,1,1],[[5,4,0],[5,3,1],[5,2,2],[5,1,3],[5,0,4],[4,5,0],[4,4,1],[4,3,2],[4,2,3],[4,1,4],[4,0,5],[3,5,1],[3,4,2],[3,3,3],[3,2,4],[3,1,5],[2,5,2],[2,4,3],[2,3,4],[2,2,5],[1,5,3],[1,4,4],[1,3,5],[0,5,4],[0,4,5]]], + "(5, 5, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[5,5,0],[5,4,1],[5,3,2],[5,2,3],[5,1,4],[5,0,5],[4,5,1],[4,4,2],[4,3,3],[4,2,4],[4,1,5],[3,5,2],[3,4,3],[3,3,4],[3,2,5],[2,5,3],[2,4,4],[2,3,5],[1,5,4],[1,4,5],[0,5,5]]], + "(6, 1, 0)": [[1,1,1,2,1,1,2,2,1,1,2,2,2,1,1,2,2,2,2,1,1,2,2,2,2,2,1,1,1,1,1,1,1],[[6,1,0],[6,0,1],[5,2,0],[5,1,1],[5,0,2],[4,3,0],[4,2,1],[4,1,2],[4,0,3],[3,4,0],[3,3,1],[3,2,2],[3,1,3],[3,0,4],[2,5,0],[2,4,1],[2,3,2],[2,2,3],[2,1,4],[2,0,5],[1,6,0],[1,5,1],[1,4,2],[1,3,3],[1,2,4],[1,1,5],[1,0,6],[0,6,1],[0,5,2],[0,4,3],[0,3,4],[0,2,5],[0,1,6]]], + "(6, 2, 0)": [[1,1,1,1,2,2,1,1,2,3,2,1,1,2,3,3,2,1,1,2,3,3,3,2,1,1,2,2,2,2,1,1,1,1,1,1],[[6,2,0],[6,1,1],[6,0,2],[5,3,0],[5,2,1],[5,1,2],[5,0,3],[4,4,0],[4,3,1],[4,2,2],[4,1,3],[4,0,4],[3,5,0],[3,4,1],[3,3,2],[3,2,3],[3,1,4],[3,0,5],[2,6,0],[2,5,1],[2,4,2],[2,3,3],[2,2,4],[2,1,5],[2,0,6],[1,6,1],[1,5,2],[1,4,3],[1,3,4],[1,2,5],[1,1,6],[0,6,2],[0,5,3],[0,4,4],[0,3,5],[0,2,6]]], + "(6, 3, 0)": [[1,1,1,1,1,2,2,2,1,1,2,3,3,2,1,1,2,3,4,3,2,1,1,2,3,3,2,1,1,2,2,2,1,1,1,1,1],[[6,3,0],[6,2,1],[6,1,2],[6,0,3],[5,4,0],[5,3,1],[5,2,2],[5,1,3],[5,0,4],[4,5,0],[4,4,1],[4,3,2],[4,2,3],[4,1,4],[4,0,5],[3,6,0],[3,5,1],[3,4,2],[3,3,3],[3,2,4],[3,1,5],[3,0,6],[2,6,1],[2,5,2],[2,4,3],[2,3,4],[2,2,5],[2,1,6],[1,6,2],[1,5,3],[1,4,4],[1,3,5],[1,2,6],[0,6,3],[0,5,4],[0,4,5],[0,3,6]]], + "(6, 4, 0)": [[1,1,1,1,1,1,2,2,2,2,1,1,2,3,3,3,2,1,1,2,3,3,2,1,1,2,3,2,1,1,2,2,1,1,1,1],[[6,4,0],[6,3,1],[6,2,2],[6,1,3],[6,0,4],[5,5,0],[5,4,1],[5,3,2],[5,2,3],[5,1,4],[5,0,5],[4,6,0],[4,5,1],[4,4,2],[4,3,3],[4,2,4],[4,1,5],[4,0,6],[3,6,1],[3,5,2],[3,4,3],[3,3,4],[3,2,5],[3,1,6],[2,6,2],[2,5,3],[2,4,4],[2,3,5],[2,2,6],[1,6,3],[1,5,4],[1,4,5],[1,3,6],[0,6,4],[0,5,5],[0,4,6]]] }, "SU(4)": { "(0, 0, 0, 0)": [[1],[[0,0,0,0]]], @@ -192,10 +217,15 @@ "(3, 2, 0, 0)": [[1,1,1,1,1,1,1,2,2,2,3,2,1,2,2,1,1,1,2,3,2,1,3,3,1,1,2,1,1,1,1,1,2,2,1,1,2,1,1,1],[[3,2,0,0],[3,1,1,0],[3,1,0,1],[3,0,2,0],[3,0,1,1],[3,0,0,2],[2,3,0,0],[2,2,1,0],[2,2,0,1],[2,1,2,0],[2,1,1,1],[2,1,0,2],[2,0,3,0],[2,0,2,1],[2,0,1,2],[2,0,0,3],[1,3,1,0],[1,3,0,1],[1,2,2,0],[1,2,1,1],[1,2,0,2],[1,1,3,0],[1,1,2,1],[1,1,1,2],[1,1,0,3],[1,0,3,1],[1,0,2,2],[1,0,1,3],[0,3,2,0],[0,3,1,1],[0,3,0,2],[0,2,3,0],[0,2,2,1],[0,2,1,2],[0,2,0,3],[0,1,3,1],[0,1,2,2],[0,1,1,3],[0,0,3,2],[0,0,2,3]]], "(3, 2, 1, 0)": [[1,1,1,2,1,1,1,1,1,2,4,2,1,4,4,1,1,2,1,1,2,1,1,4,4,1,2,4,2,1,1,1,1,1,2,1,1,1],[[3,2,1,0],[3,2,0,1],[3,1,2,0],[3,1,1,1],[3,1,0,2],[3,0,2,1],[3,0,1,2],[2,3,1,0],[2,3,0,1],[2,2,2,0],[2,2,1,1],[2,2,0,2],[2,1,3,0],[2,1,2,1],[2,1,1,2],[2,1,0,3],[2,0,3,1],[2,0,2,2],[2,0,1,3],[1,3,2,0],[1,3,1,1],[1,3,0,2],[1,2,3,0],[1,2,2,1],[1,2,1,2],[1,2,0,3],[1,1,3,1],[1,1,2,2],[1,1,1,3],[1,0,3,2],[1,0,2,3],[0,3,2,1],[0,3,1,2],[0,2,3,1],[0,2,2,2],[0,2,1,3],[0,1,3,2],[0,1,2,3]]], "(3, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,1,1,3,1,1,1,1,1,1],[[3,2,2,0],[3,2,1,1],[3,2,0,2],[3,1,2,1],[3,1,1,2],[3,0,2,2],[2,3,2,0],[2,3,1,1],[2,3,0,2],[2,2,3,0],[2,2,2,1],[2,2,1,2],[2,2,0,3],[2,1,3,1],[2,1,2,2],[2,1,1,3],[2,0,3,2],[2,0,2,3],[1,3,2,1],[1,3,1,2],[1,2,3,1],[1,2,2,2],[1,2,1,3],[1,1,3,2],[1,1,2,3],[0,3,2,2],[0,2,3,2],[0,2,2,3]]], + "(3, 3, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,2,2,1,1,1,1,1,1,1,1,2,2,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,3,0,0],[3,2,1,0],[3,2,0,1],[3,1,2,0],[3,1,1,1],[3,1,0,2],[3,0,3,0],[3,0,2,1],[3,0,1,2],[3,0,0,3],[2,3,1,0],[2,3,0,1],[2,2,2,0],[2,2,1,1],[2,2,0,2],[2,1,3,0],[2,1,2,1],[2,1,1,2],[2,1,0,3],[2,0,3,1],[2,0,2,2],[2,0,1,3],[1,3,2,0],[1,3,1,1],[1,3,0,2],[1,2,3,0],[1,2,2,1],[1,2,1,2],[1,2,0,3],[1,1,3,1],[1,1,2,2],[1,1,1,3],[1,0,3,2],[1,0,2,3],[0,3,3,0],[0,3,2,1],[0,3,1,2],[0,3,0,3],[0,2,3,1],[0,2,2,2],[0,2,1,3],[0,1,3,2],[0,1,2,3],[0,0,3,3]]], "(3, 3, 1, 0)": [[1,1,1,2,1,1,2,2,1,1,1,1,1,2,1,1,3,3,1,2,3,2,1,1,1,2,2,1,2,3,2,2,2,1,1,1,1,1,1,1],[[3,3,1,0],[3,3,0,1],[3,2,2,0],[3,2,1,1],[3,2,0,2],[3,1,3,0],[3,1,2,1],[3,1,1,2],[3,1,0,3],[3,0,3,1],[3,0,2,2],[3,0,1,3],[2,3,2,0],[2,3,1,1],[2,3,0,2],[2,2,3,0],[2,2,2,1],[2,2,1,2],[2,2,0,3],[2,1,3,1],[2,1,2,2],[2,1,1,3],[2,0,3,2],[2,0,2,3],[1,3,3,0],[1,3,2,1],[1,3,1,2],[1,3,0,3],[1,2,3,1],[1,2,2,2],[1,2,1,3],[1,1,3,2],[1,1,2,3],[1,0,3,3],[0,3,3,1],[0,3,2,2],[0,3,1,3],[0,2,3,2],[0,2,2,3],[0,1,3,3]]], "(3, 3, 2, 0)": [[1,1,1,1,2,2,1,1,2,1,1,1,1,2,2,1,2,3,2,2,2,1,1,2,1,2,2,1,1,1,1],[[3,3,2,0],[3,3,1,1],[3,3,0,2],[3,2,3,0],[3,2,2,1],[3,2,1,2],[3,2,0,3],[3,1,3,1],[3,1,2,2],[3,1,1,3],[3,0,3,2],[3,0,2,3],[2,3,3,0],[2,3,2,1],[2,3,1,2],[2,3,0,3],[2,2,3,1],[2,2,2,2],[2,2,1,3],[2,1,3,2],[2,1,2,3],[2,0,3,3],[1,3,3,1],[1,3,2,2],[1,3,1,3],[1,2,3,2],[1,2,2,3],[1,1,3,3],[0,3,3,2],[0,3,2,3],[0,2,3,3]]], "(3, 3, 3, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,3,3,0],[3,3,2,1],[3,3,1,2],[3,3,0,3],[3,2,3,1],[3,2,2,2],[3,2,1,3],[3,1,3,2],[3,1,2,3],[3,0,3,3],[2,3,3,1],[2,3,2,2],[2,3,1,3],[2,2,3,2],[2,2,2,3],[2,1,3,3],[1,3,3,2],[1,3,2,3],[1,2,3,3],[0,3,3,3]]], - "(4, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,1,1,1,3,3,1,1,3,6,3,1,1,3,3,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1],[[4,2,2,0],[4,2,1,1],[4,2,0,2],[4,1,2,1],[4,1,1,2],[4,0,2,2],[3,3,2,0],[3,3,1,1],[3,3,0,2],[3,2,3,0],[3,2,2,1],[3,2,1,2],[3,2,0,3],[3,1,3,1],[3,1,2,2],[3,1,1,3],[3,0,3,2],[3,0,2,3],[2,4,2,0],[2,4,1,1],[2,4,0,2],[2,3,3,0],[2,3,2,1],[2,3,1,2],[2,3,0,3],[2,2,4,0],[2,2,3,1],[2,2,2,2],[2,2,1,3],[2,2,0,4],[2,1,4,1],[2,1,3,2],[2,1,2,3],[2,1,1,4],[2,0,4,2],[2,0,3,3],[2,0,2,4],[1,4,2,1],[1,4,1,2],[1,3,3,1],[1,3,2,2],[1,3,1,3],[1,2,4,1],[1,2,3,2],[1,2,2,3],[1,2,1,4],[1,1,4,2],[1,1,3,3],[1,1,2,4],[0,4,2,2],[0,3,3,2],[0,3,2,3],[0,2,4,2],[0,2,3,3],[0,2,2,4]]] + "(4, 1, 1, 0)": [[1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,3,1,1,3,3,1,1,3,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[4,1,1,0],[4,1,0,1],[4,0,1,1],[3,2,1,0],[3,2,0,1],[3,1,2,0],[3,1,1,1],[3,1,0,2],[3,0,2,1],[3,0,1,2],[2,3,1,0],[2,3,0,1],[2,2,2,0],[2,2,1,1],[2,2,0,2],[2,1,3,0],[2,1,2,1],[2,1,1,2],[2,1,0,3],[2,0,3,1],[2,0,2,2],[2,0,1,3],[1,4,1,0],[1,4,0,1],[1,3,2,0],[1,3,1,1],[1,3,0,2],[1,2,3,0],[1,2,2,1],[1,2,1,2],[1,2,0,3],[1,1,4,0],[1,1,3,1],[1,1,2,2],[1,1,1,3],[1,1,0,4],[1,0,4,1],[1,0,3,2],[1,0,2,3],[1,0,1,4],[0,4,1,1],[0,3,2,1],[0,3,1,2],[0,2,3,1],[0,2,2,2],[0,2,1,3],[0,1,4,1],[0,1,3,2],[0,1,2,3],[0,1,1,4]]], + "(4, 2, 1, 0)": [[1,1,1,2,1,1,1,1,1,2,4,2,1,4,4,1,1,2,1,1,1,2,4,2,2,6,6,2,1,4,6,4,1,1,2,2,1,1,2,1,1,4,4,1,1,4,6,4,1,2,4,4,2,1,1,1,1,1,1,2,1,1,2,2,1,1,1,1],[[4,2,1,0],[4,2,0,1],[4,1,2,0],[4,1,1,1],[4,1,0,2],[4,0,2,1],[4,0,1,2],[3,3,1,0],[3,3,0,1],[3,2,2,0],[3,2,1,1],[3,2,0,2],[3,1,3,0],[3,1,2,1],[3,1,1,2],[3,1,0,3],[3,0,3,1],[3,0,2,2],[3,0,1,3],[2,4,1,0],[2,4,0,1],[2,3,2,0],[2,3,1,1],[2,3,0,2],[2,2,3,0],[2,2,2,1],[2,2,1,2],[2,2,0,3],[2,1,4,0],[2,1,3,1],[2,1,2,2],[2,1,1,3],[2,1,0,4],[2,0,4,1],[2,0,3,2],[2,0,2,3],[2,0,1,4],[1,4,2,0],[1,4,1,1],[1,4,0,2],[1,3,3,0],[1,3,2,1],[1,3,1,2],[1,3,0,3],[1,2,4,0],[1,2,3,1],[1,2,2,2],[1,2,1,3],[1,2,0,4],[1,1,4,1],[1,1,3,2],[1,1,2,3],[1,1,1,4],[1,0,4,2],[1,0,3,3],[1,0,2,4],[0,4,2,1],[0,4,1,2],[0,3,3,1],[0,3,2,2],[0,3,1,3],[0,2,4,1],[0,2,3,2],[0,2,2,3],[0,2,1,4],[0,1,4,2],[0,1,3,3],[0,1,2,4]]], + "(4, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,1,1,1,3,3,1,1,3,6,3,1,1,3,3,1,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1],[[4,2,2,0],[4,2,1,1],[4,2,0,2],[4,1,2,1],[4,1,1,2],[4,0,2,2],[3,3,2,0],[3,3,1,1],[3,3,0,2],[3,2,3,0],[3,2,2,1],[3,2,1,2],[3,2,0,3],[3,1,3,1],[3,1,2,2],[3,1,1,3],[3,0,3,2],[3,0,2,3],[2,4,2,0],[2,4,1,1],[2,4,0,2],[2,3,3,0],[2,3,2,1],[2,3,1,2],[2,3,0,3],[2,2,4,0],[2,2,3,1],[2,2,2,2],[2,2,1,3],[2,2,0,4],[2,1,4,1],[2,1,3,2],[2,1,2,3],[2,1,1,4],[2,0,4,2],[2,0,3,3],[2,0,2,4],[1,4,2,1],[1,4,1,2],[1,3,3,1],[1,3,2,2],[1,3,1,3],[1,2,4,1],[1,2,3,2],[1,2,2,3],[1,2,1,4],[1,1,4,2],[1,1,3,3],[1,1,2,4],[0,4,2,2],[0,3,3,2],[0,3,2,3],[0,2,4,2],[0,2,3,3],[0,2,2,4]]], + "(4, 3, 2, 0)": [[1,1,1,1,2,2,1,1,2,1,1,1,1,1,1,2,4,4,2,1,4,6,4,1,1,4,4,1,1,2,1,1,2,2,1,1,4,6,4,1,2,6,6,2,2,4,2,1,1,1,2,1,1,4,4,1,2,4,2,1,1,1,1,1,2,1,1,1],[[4,3,2,0],[4,3,1,1],[4,3,0,2],[4,2,3,0],[4,2,2,1],[4,2,1,2],[4,2,0,3],[4,1,3,1],[4,1,2,2],[4,1,1,3],[4,0,3,2],[4,0,2,3],[3,4,2,0],[3,4,1,1],[3,4,0,2],[3,3,3,0],[3,3,2,1],[3,3,1,2],[3,3,0,3],[3,2,4,0],[3,2,3,1],[3,2,2,2],[3,2,1,3],[3,2,0,4],[3,1,4,1],[3,1,3,2],[3,1,2,3],[3,1,1,4],[3,0,4,2],[3,0,3,3],[3,0,2,4],[2,4,3,0],[2,4,2,1],[2,4,1,2],[2,4,0,3],[2,3,4,0],[2,3,3,1],[2,3,2,2],[2,3,1,3],[2,3,0,4],[2,2,4,1],[2,2,3,2],[2,2,2,3],[2,2,1,4],[2,1,4,2],[2,1,3,3],[2,1,2,4],[2,0,4,3],[2,0,3,4],[1,4,3,1],[1,4,2,2],[1,4,1,3],[1,3,4,1],[1,3,3,2],[1,3,2,3],[1,3,1,4],[1,2,4,2],[1,2,3,3],[1,2,2,4],[1,1,4,3],[1,1,3,4],[0,4,3,2],[0,4,2,3],[0,3,4,2],[0,3,3,3],[0,3,2,4],[0,2,4,3],[0,2,3,4]]], + "(4, 3, 3, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,1,1,3,3,1,1,3,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,1,1,3,1,1,1,1,1,1],[[4,3,3,0],[4,3,2,1],[4,3,1,2],[4,3,0,3],[4,2,3,1],[4,2,2,2],[4,2,1,3],[4,1,3,2],[4,1,2,3],[4,0,3,3],[3,4,3,0],[3,4,2,1],[3,4,1,2],[3,4,0,3],[3,3,4,0],[3,3,3,1],[3,3,2,2],[3,3,1,3],[3,3,0,4],[3,2,4,1],[3,2,3,2],[3,2,2,3],[3,2,1,4],[3,1,4,2],[3,1,3,3],[3,1,2,4],[3,0,4,3],[3,0,3,4],[2,4,3,1],[2,4,2,2],[2,4,1,3],[2,3,4,1],[2,3,3,2],[2,3,2,3],[2,3,1,4],[2,2,4,2],[2,2,3,3],[2,2,2,4],[2,1,4,3],[2,1,3,4],[1,4,3,2],[1,4,2,3],[1,3,4,2],[1,3,3,3],[1,3,2,4],[1,2,4,3],[1,2,3,4],[0,4,3,3],[0,3,4,3],[0,3,3,4]]] }, "SU(5)": { "(0, 0, 0, 0, 0)": [[1],[[0,0,0,0,0]]], @@ -213,10 +243,15 @@ "(2, 2, 2, 0, 0)": [[1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,0,0],[2,2,1,1,0],[2,2,1,0,1],[2,2,0,2,0],[2,2,0,1,1],[2,2,0,0,2],[2,1,2,1,0],[2,1,2,0,1],[2,1,1,2,0],[2,1,1,1,1],[2,1,1,0,2],[2,1,0,2,1],[2,1,0,1,2],[2,0,2,2,0],[2,0,2,1,1],[2,0,2,0,2],[2,0,1,2,1],[2,0,1,1,2],[2,0,0,2,2],[1,2,2,1,0],[1,2,2,0,1],[1,2,1,2,0],[1,2,1,1,1],[1,2,1,0,2],[1,2,0,2,1],[1,2,0,1,2],[1,1,2,2,0],[1,1,2,1,1],[1,1,2,0,2],[1,1,1,2,1],[1,1,1,1,2],[1,1,0,2,2],[1,0,2,2,1],[1,0,2,1,2],[1,0,1,2,2],[0,2,2,2,0],[0,2,2,1,1],[0,2,2,0,2],[0,2,1,2,1],[0,2,1,1,2],[0,2,0,2,2],[0,1,2,2,1],[0,1,2,1,2],[0,1,1,2,2],[0,0,2,2,2]]], "(2, 2, 2, 1, 0)": [[1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1],[[2,2,2,1,0],[2,2,2,0,1],[2,2,1,2,0],[2,2,1,1,1],[2,2,1,0,2],[2,2,0,2,1],[2,2,0,1,2],[2,1,2,2,0],[2,1,2,1,1],[2,1,2,0,2],[2,1,1,2,1],[2,1,1,1,2],[2,1,0,2,2],[2,0,2,2,1],[2,0,2,1,2],[2,0,1,2,2],[1,2,2,2,0],[1,2,2,1,1],[1,2,2,0,2],[1,2,1,2,1],[1,2,1,1,2],[1,2,0,2,2],[1,1,2,2,1],[1,1,2,1,2],[1,1,1,2,2],[1,0,2,2,2],[0,2,2,2,1],[0,2,2,1,2],[0,2,1,2,2],[0,1,2,2,2]]], "(2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,0],[2,2,2,1,1],[2,2,2,0,2],[2,2,1,2,1],[2,2,1,1,2],[2,2,0,2,2],[2,1,2,2,1],[2,1,2,1,2],[2,1,1,2,2],[2,0,2,2,2],[1,2,2,2,1],[1,2,2,1,2],[1,2,1,2,2],[1,1,2,2,2],[0,2,2,2,2]]], + "(3, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,0,0,0,0],[2,1,0,0,0],[2,0,1,0,0],[2,0,0,1,0],[2,0,0,0,1],[1,2,0,0,0],[1,1,1,0,0],[1,1,0,1,0],[1,1,0,0,1],[1,0,2,0,0],[1,0,1,1,0],[1,0,1,0,1],[1,0,0,2,0],[1,0,0,1,1],[1,0,0,0,2],[0,3,0,0,0],[0,2,1,0,0],[0,2,0,1,0],[0,2,0,0,1],[0,1,2,0,0],[0,1,1,1,0],[0,1,1,0,1],[0,1,0,2,0],[0,1,0,1,1],[0,1,0,0,2],[0,0,3,0,0],[0,0,2,1,0],[0,0,2,0,1],[0,0,1,2,0],[0,0,1,1,1],[0,0,1,0,2],[0,0,0,3,0],[0,0,0,2,1],[0,0,0,1,2],[0,0,0,0,3]]], + "(3, 1, 0, 0, 0)": [[1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,2,2,2,2,3,3,2,3,2,1,2,2,2,3,2,1,2,2,1,1,1,1,1,2,2,1,2,1,1,2,2,2,3,2,1,2,2,1,1,1,1,2,1,1,2,2,1,1,1,1],[[3,1,0,0,0],[3,0,1,0,0],[3,0,0,1,0],[3,0,0,0,1],[2,2,0,0,0],[2,1,1,0,0],[2,1,0,1,0],[2,1,0,0,1],[2,0,2,0,0],[2,0,1,1,0],[2,0,1,0,1],[2,0,0,2,0],[2,0,0,1,1],[2,0,0,0,2],[1,3,0,0,0],[1,2,1,0,0],[1,2,0,1,0],[1,2,0,0,1],[1,1,2,0,0],[1,1,1,1,0],[1,1,1,0,1],[1,1,0,2,0],[1,1,0,1,1],[1,1,0,0,2],[1,0,3,0,0],[1,0,2,1,0],[1,0,2,0,1],[1,0,1,2,0],[1,0,1,1,1],[1,0,1,0,2],[1,0,0,3,0],[1,0,0,2,1],[1,0,0,1,2],[1,0,0,0,3],[0,3,1,0,0],[0,3,0,1,0],[0,3,0,0,1],[0,2,2,0,0],[0,2,1,1,0],[0,2,1,0,1],[0,2,0,2,0],[0,2,0,1,1],[0,2,0,0,2],[0,1,3,0,0],[0,1,2,1,0],[0,1,2,0,1],[0,1,1,2,0],[0,1,1,1,1],[0,1,1,0,2],[0,1,0,3,0],[0,1,0,2,1],[0,1,0,1,2],[0,1,0,0,3],[0,0,3,1,0],[0,0,3,0,1],[0,0,2,2,0],[0,0,2,1,1],[0,0,2,0,2],[0,0,1,3,0],[0,0,1,2,1],[0,0,1,1,2],[0,0,1,0,3],[0,0,0,3,1],[0,0,0,2,2],[0,0,0,1,3]]], + "(3, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,1,1,1,3,3,1,3,1,1,3,3,3,6,3,1,3,3,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,3,1,1,3,3,1,1,1,1,1,1,1,1,1,1],[[3,1,1,0,0],[3,1,0,1,0],[3,1,0,0,1],[3,0,1,1,0],[3,0,1,0,1],[3,0,0,1,1],[2,2,1,0,0],[2,2,0,1,0],[2,2,0,0,1],[2,1,2,0,0],[2,1,1,1,0],[2,1,1,0,1],[2,1,0,2,0],[2,1,0,1,1],[2,1,0,0,2],[2,0,2,1,0],[2,0,2,0,1],[2,0,1,2,0],[2,0,1,1,1],[2,0,1,0,2],[2,0,0,2,1],[2,0,0,1,2],[1,3,1,0,0],[1,3,0,1,0],[1,3,0,0,1],[1,2,2,0,0],[1,2,1,1,0],[1,2,1,0,1],[1,2,0,2,0],[1,2,0,1,1],[1,2,0,0,2],[1,1,3,0,0],[1,1,2,1,0],[1,1,2,0,1],[1,1,1,2,0],[1,1,1,1,1],[1,1,1,0,2],[1,1,0,3,0],[1,1,0,2,1],[1,1,0,1,2],[1,1,0,0,3],[1,0,3,1,0],[1,0,3,0,1],[1,0,2,2,0],[1,0,2,1,1],[1,0,2,0,2],[1,0,1,3,0],[1,0,1,2,1],[1,0,1,1,2],[1,0,1,0,3],[1,0,0,3,1],[1,0,0,2,2],[1,0,0,1,3],[0,3,1,1,0],[0,3,1,0,1],[0,3,0,1,1],[0,2,2,1,0],[0,2,2,0,1],[0,2,1,2,0],[0,2,1,1,1],[0,2,1,0,2],[0,2,0,2,1],[0,2,0,1,2],[0,1,3,1,0],[0,1,3,0,1],[0,1,2,2,0],[0,1,2,1,1],[0,1,2,0,2],[0,1,1,3,0],[0,1,1,2,1],[0,1,1,1,2],[0,1,1,0,3],[0,1,0,3,1],[0,1,0,2,2],[0,1,0,1,3],[0,0,3,1,1],[0,0,2,2,1],[0,0,2,1,2],[0,0,1,3,1],[0,0,1,2,2],[0,0,1,1,3]]], "(3, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,4,1,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,1,1,1,0],[3,1,1,0,1],[3,1,0,1,1],[3,0,1,1,1],[2,2,1,1,0],[2,2,1,0,1],[2,2,0,1,1],[2,1,2,1,0],[2,1,2,0,1],[2,1,1,2,0],[2,1,1,1,1],[2,1,1,0,2],[2,1,0,2,1],[2,1,0,1,2],[2,0,2,1,1],[2,0,1,2,1],[2,0,1,1,2],[1,3,1,1,0],[1,3,1,0,1],[1,3,0,1,1],[1,2,2,1,0],[1,2,2,0,1],[1,2,1,2,0],[1,2,1,1,1],[1,2,1,0,2],[1,2,0,2,1],[1,2,0,1,2],[1,1,3,1,0],[1,1,3,0,1],[1,1,2,2,0],[1,1,2,1,1],[1,1,2,0,2],[1,1,1,3,0],[1,1,1,2,1],[1,1,1,1,2],[1,1,1,0,3],[1,1,0,3,1],[1,1,0,2,2],[1,1,0,1,3],[1,0,3,1,1],[1,0,2,2,1],[1,0,2,1,2],[1,0,1,3,1],[1,0,1,2,2],[1,0,1,1,3],[0,3,1,1,1],[0,2,2,1,1],[0,2,1,2,1],[0,2,1,1,2],[0,1,3,1,1],[0,1,2,2,1],[0,1,2,1,2],[0,1,1,3,1],[0,1,1,2,2],[0,1,1,1,3]]], "(3, 2, 1, 1, 0)": [[1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,2,2,2,6,2,2,2,1,1,2,6,2,1,6,6,1,1,2,1,1,2,2,1,2,1,1,1,1,3,1,1,1,1,1,2,6,2,1,6,6,1,1,2,1,1,3,1,1,6,6,1,3,6,3,1,1,1,1,1,2,1,1,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1],[[3,2,1,1,0],[3,2,1,0,1],[3,2,0,1,1],[3,1,2,1,0],[3,1,2,0,1],[3,1,1,2,0],[3,1,1,1,1],[3,1,1,0,2],[3,1,0,2,1],[3,1,0,1,2],[3,0,2,1,1],[3,0,1,2,1],[3,0,1,1,2],[2,3,1,1,0],[2,3,1,0,1],[2,3,0,1,1],[2,2,2,1,0],[2,2,2,0,1],[2,2,1,2,0],[2,2,1,1,1],[2,2,1,0,2],[2,2,0,2,1],[2,2,0,1,2],[2,1,3,1,0],[2,1,3,0,1],[2,1,2,2,0],[2,1,2,1,1],[2,1,2,0,2],[2,1,1,3,0],[2,1,1,2,1],[2,1,1,1,2],[2,1,1,0,3],[2,1,0,3,1],[2,1,0,2,2],[2,1,0,1,3],[2,0,3,1,1],[2,0,2,2,1],[2,0,2,1,2],[2,0,1,3,1],[2,0,1,2,2],[2,0,1,1,3],[1,3,2,1,0],[1,3,2,0,1],[1,3,1,2,0],[1,3,1,1,1],[1,3,1,0,2],[1,3,0,2,1],[1,3,0,1,2],[1,2,3,1,0],[1,2,3,0,1],[1,2,2,2,0],[1,2,2,1,1],[1,2,2,0,2],[1,2,1,3,0],[1,2,1,2,1],[1,2,1,1,2],[1,2,1,0,3],[1,2,0,3,1],[1,2,0,2,2],[1,2,0,1,3],[1,1,3,2,0],[1,1,3,1,1],[1,1,3,0,2],[1,1,2,3,0],[1,1,2,2,1],[1,1,2,1,2],[1,1,2,0,3],[1,1,1,3,1],[1,1,1,2,2],[1,1,1,1,3],[1,1,0,3,2],[1,1,0,2,3],[1,0,3,2,1],[1,0,3,1,2],[1,0,2,3,1],[1,0,2,2,2],[1,0,2,1,3],[1,0,1,3,2],[1,0,1,2,3],[0,3,2,1,1],[0,3,1,2,1],[0,3,1,1,2],[0,2,3,1,1],[0,2,2,2,1],[0,2,2,1,2],[0,2,1,3,1],[0,2,1,2,2],[0,2,1,1,3],[0,1,3,2,1],[0,1,3,1,2],[0,1,2,3,1],[0,1,2,2,2],[0,1,2,1,3],[0,1,1,3,2],[0,1,1,2,3]]], "(3, 2, 2, 1, 0)": [[1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,1,1,2,1,1,1,1,1,3,6,3,1,6,6,1,1,3,1,1,2,1,1,6,6,1,2,6,2,1,1,1,1,1,3,1,1,1,1,2,1,2,2,1,1,2,1,1,6,6,1,2,6,2,1,1,2,2,2,6,2,2,2,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1],[[3,2,2,1,0],[3,2,2,0,1],[3,2,1,2,0],[3,2,1,1,1],[3,2,1,0,2],[3,2,0,2,1],[3,2,0,1,2],[3,1,2,2,0],[3,1,2,1,1],[3,1,2,0,2],[3,1,1,2,1],[3,1,1,1,2],[3,1,0,2,2],[3,0,2,2,1],[3,0,2,1,2],[3,0,1,2,2],[2,3,2,1,0],[2,3,2,0,1],[2,3,1,2,0],[2,3,1,1,1],[2,3,1,0,2],[2,3,0,2,1],[2,3,0,1,2],[2,2,3,1,0],[2,2,3,0,1],[2,2,2,2,0],[2,2,2,1,1],[2,2,2,0,2],[2,2,1,3,0],[2,2,1,2,1],[2,2,1,1,2],[2,2,1,0,3],[2,2,0,3,1],[2,2,0,2,2],[2,2,0,1,3],[2,1,3,2,0],[2,1,3,1,1],[2,1,3,0,2],[2,1,2,3,0],[2,1,2,2,1],[2,1,2,1,2],[2,1,2,0,3],[2,1,1,3,1],[2,1,1,2,2],[2,1,1,1,3],[2,1,0,3,2],[2,1,0,2,3],[2,0,3,2,1],[2,0,3,1,2],[2,0,2,3,1],[2,0,2,2,2],[2,0,2,1,3],[2,0,1,3,2],[2,0,1,2,3],[1,3,2,2,0],[1,3,2,1,1],[1,3,2,0,2],[1,3,1,2,1],[1,3,1,1,2],[1,3,0,2,2],[1,2,3,2,0],[1,2,3,1,1],[1,2,3,0,2],[1,2,2,3,0],[1,2,2,2,1],[1,2,2,1,2],[1,2,2,0,3],[1,2,1,3,1],[1,2,1,2,2],[1,2,1,1,3],[1,2,0,3,2],[1,2,0,2,3],[1,1,3,2,1],[1,1,3,1,2],[1,1,2,3,1],[1,1,2,2,2],[1,1,2,1,3],[1,1,1,3,2],[1,1,1,2,3],[1,0,3,2,2],[1,0,2,3,2],[1,0,2,2,3],[0,3,2,2,1],[0,3,2,1,2],[0,3,1,2,2],[0,2,3,2,1],[0,2,3,1,2],[0,2,2,3,1],[0,2,2,2,2],[0,2,2,1,3],[0,2,1,3,2],[0,2,1,2,3],[0,1,3,2,2],[0,1,2,3,2],[0,1,2,2,3]]], "(3, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,1,4,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1],[[3,2,2,2,0],[3,2,2,1,1],[3,2,2,0,2],[3,2,1,2,1],[3,2,1,1,2],[3,2,0,2,2],[3,1,2,2,1],[3,1,2,1,2],[3,1,1,2,2],[3,0,2,2,2],[2,3,2,2,0],[2,3,2,1,1],[2,3,2,0,2],[2,3,1,2,1],[2,3,1,1,2],[2,3,0,2,2],[2,2,3,2,0],[2,2,3,1,1],[2,2,3,0,2],[2,2,2,3,0],[2,2,2,2,1],[2,2,2,1,2],[2,2,2,0,3],[2,2,1,3,1],[2,2,1,2,2],[2,2,1,1,3],[2,2,0,3,2],[2,2,0,2,3],[2,1,3,2,1],[2,1,3,1,2],[2,1,2,3,1],[2,1,2,2,2],[2,1,2,1,3],[2,1,1,3,2],[2,1,1,2,3],[2,0,3,2,2],[2,0,2,3,2],[2,0,2,2,3],[1,3,2,2,1],[1,3,2,1,2],[1,3,1,2,2],[1,2,3,2,1],[1,2,3,1,2],[1,2,2,3,1],[1,2,2,2,2],[1,2,2,1,3],[1,2,1,3,2],[1,2,1,2,3],[1,1,3,2,2],[1,1,2,3,2],[1,1,2,2,3],[0,3,2,2,2],[0,2,3,2,2],[0,2,2,3,2],[0,2,2,2,3]]], + "(3, 3, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,3,3,1,1,3,1,1,1,1,3,3,1,3,6,3,3,3,1,1,3,1,3,3,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,1,1,1,1,1],[[3,3,2,2,0],[3,3,2,1,1],[3,3,2,0,2],[3,3,1,2,1],[3,3,1,1,2],[3,3,0,2,2],[3,2,3,2,0],[3,2,3,1,1],[3,2,3,0,2],[3,2,2,3,0],[3,2,2,2,1],[3,2,2,1,2],[3,2,2,0,3],[3,2,1,3,1],[3,2,1,2,2],[3,2,1,1,3],[3,2,0,3,2],[3,2,0,2,3],[3,1,3,2,1],[3,1,3,1,2],[3,1,2,3,1],[3,1,2,2,2],[3,1,2,1,3],[3,1,1,3,2],[3,1,1,2,3],[3,0,3,2,2],[3,0,2,3,2],[3,0,2,2,3],[2,3,3,2,0],[2,3,3,1,1],[2,3,3,0,2],[2,3,2,3,0],[2,3,2,2,1],[2,3,2,1,2],[2,3,2,0,3],[2,3,1,3,1],[2,3,1,2,2],[2,3,1,1,3],[2,3,0,3,2],[2,3,0,2,3],[2,2,3,3,0],[2,2,3,2,1],[2,2,3,1,2],[2,2,3,0,3],[2,2,2,3,1],[2,2,2,2,2],[2,2,2,1,3],[2,2,1,3,2],[2,2,1,2,3],[2,2,0,3,3],[2,1,3,3,1],[2,1,3,2,2],[2,1,3,1,3],[2,1,2,3,2],[2,1,2,2,3],[2,1,1,3,3],[2,0,3,3,2],[2,0,3,2,3],[2,0,2,3,3],[1,3,3,2,1],[1,3,3,1,2],[1,3,2,3,1],[1,3,2,2,2],[1,3,2,1,3],[1,3,1,3,2],[1,3,1,2,3],[1,2,3,3,1],[1,2,3,2,2],[1,2,3,1,3],[1,2,2,3,2],[1,2,2,2,3],[1,2,1,3,3],[1,1,3,3,2],[1,1,3,2,3],[1,1,2,3,3],[0,3,3,2,2],[0,3,2,3,2],[0,3,2,2,3],[0,2,3,3,2],[0,2,3,2,3],[0,2,2,3,3]]], + "(3, 3, 3, 2, 0)": [[1,1,1,1,2,2,1,1,2,1,1,1,1,2,2,1,2,3,2,2,2,1,1,2,1,2,2,1,1,1,1,1,2,2,1,2,3,2,2,2,1,2,3,2,3,3,2,2,2,2,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1],[[3,3,3,2,0],[3,3,3,1,1],[3,3,3,0,2],[3,3,2,3,0],[3,3,2,2,1],[3,3,2,1,2],[3,3,2,0,3],[3,3,1,3,1],[3,3,1,2,2],[3,3,1,1,3],[3,3,0,3,2],[3,3,0,2,3],[3,2,3,3,0],[3,2,3,2,1],[3,2,3,1,2],[3,2,3,0,3],[3,2,2,3,1],[3,2,2,2,2],[3,2,2,1,3],[3,2,1,3,2],[3,2,1,2,3],[3,2,0,3,3],[3,1,3,3,1],[3,1,3,2,2],[3,1,3,1,3],[3,1,2,3,2],[3,1,2,2,3],[3,1,1,3,3],[3,0,3,3,2],[3,0,3,2,3],[3,0,2,3,3],[2,3,3,3,0],[2,3,3,2,1],[2,3,3,1,2],[2,3,3,0,3],[2,3,2,3,1],[2,3,2,2,2],[2,3,2,1,3],[2,3,1,3,2],[2,3,1,2,3],[2,3,0,3,3],[2,2,3,3,1],[2,2,3,2,2],[2,2,3,1,3],[2,2,2,3,2],[2,2,2,2,3],[2,2,1,3,3],[2,1,3,3,2],[2,1,3,2,3],[2,1,2,3,3],[2,0,3,3,3],[1,3,3,3,1],[1,3,3,2,2],[1,3,3,1,3],[1,3,2,3,2],[1,3,2,2,3],[1,3,1,3,3],[1,2,3,3,2],[1,2,3,2,3],[1,2,2,3,3],[1,1,3,3,3],[0,3,3,3,2],[0,3,3,2,3],[0,3,2,3,3],[0,2,3,3,3]]], "(3, 3, 3, 3, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,3,3,3,0],[3,3,3,2,1],[3,3,3,1,2],[3,3,3,0,3],[3,3,2,3,1],[3,3,2,2,2],[3,3,2,1,3],[3,3,1,3,2],[3,3,1,2,3],[3,3,0,3,3],[3,2,3,3,1],[3,2,3,2,2],[3,2,3,1,3],[3,2,2,3,2],[3,2,2,2,3],[3,2,1,3,3],[3,1,3,3,2],[3,1,3,2,3],[3,1,2,3,3],[3,0,3,3,3],[2,3,3,3,1],[2,3,3,2,2],[2,3,3,1,3],[2,3,2,3,2],[2,3,2,2,3],[2,3,1,3,3],[2,2,3,3,2],[2,2,3,2,3],[2,2,2,3,3],[2,1,3,3,3],[1,3,3,3,2],[1,3,3,2,3],[1,3,2,3,3],[1,2,3,3,3],[0,3,3,3,3]]] }, "SU(6)": { @@ -232,13 +267,74 @@ "(2, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,0,0],[2,1,1,0,1,0],[2,1,1,0,0,1],[2,1,0,1,1,0],[2,1,0,1,0,1],[2,1,0,0,1,1],[2,0,1,1,1,0],[2,0,1,1,0,1],[2,0,1,0,1,1],[2,0,0,1,1,1],[1,2,1,1,0,0],[1,2,1,0,1,0],[1,2,1,0,0,1],[1,2,0,1,1,0],[1,2,0,1,0,1],[1,2,0,0,1,1],[1,1,2,1,0,0],[1,1,2,0,1,0],[1,1,2,0,0,1],[1,1,1,2,0,0],[1,1,1,1,1,0],[1,1,1,1,0,1],[1,1,1,0,2,0],[1,1,1,0,1,1],[1,1,1,0,0,2],[1,1,0,2,1,0],[1,1,0,2,0,1],[1,1,0,1,2,0],[1,1,0,1,1,1],[1,1,0,1,0,2],[1,1,0,0,2,1],[1,1,0,0,1,2],[1,0,2,1,1,0],[1,0,2,1,0,1],[1,0,2,0,1,1],[1,0,1,2,1,0],[1,0,1,2,0,1],[1,0,1,1,2,0],[1,0,1,1,1,1],[1,0,1,1,0,2],[1,0,1,0,2,1],[1,0,1,0,1,2],[1,0,0,2,1,1],[1,0,0,1,2,1],[1,0,0,1,1,2],[0,2,1,1,1,0],[0,2,1,1,0,1],[0,2,1,0,1,1],[0,2,0,1,1,1],[0,1,2,1,1,0],[0,1,2,1,0,1],[0,1,2,0,1,1],[0,1,1,2,1,0],[0,1,1,2,0,1],[0,1,1,1,2,0],[0,1,1,1,1,1],[0,1,1,1,0,2],[0,1,1,0,2,1],[0,1,1,0,1,2],[0,1,0,2,1,1],[0,1,0,1,2,1],[0,1,0,1,1,2],[0,0,2,1,1,1],[0,0,1,2,1,1],[0,0,1,1,2,1],[0,0,1,1,1,2]]], "(2, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,0],[2,1,1,1,0,1],[2,1,1,0,1,1],[2,1,0,1,1,1],[2,0,1,1,1,1],[1,2,1,1,1,0],[1,2,1,1,0,1],[1,2,1,0,1,1],[1,2,0,1,1,1],[1,1,2,1,1,0],[1,1,2,1,0,1],[1,1,2,0,1,1],[1,1,1,2,1,0],[1,1,1,2,0,1],[1,1,1,1,2,0],[1,1,1,1,1,1],[1,1,1,1,0,2],[1,1,1,0,2,1],[1,1,1,0,1,2],[1,1,0,2,1,1],[1,1,0,1,2,1],[1,1,0,1,1,2],[1,0,2,1,1,1],[1,0,1,2,1,1],[1,0,1,1,2,1],[1,0,1,1,1,2],[0,2,1,1,1,1],[0,1,2,1,1,1],[0,1,1,2,1,1],[0,1,1,1,2,1],[0,1,1,1,1,2]]], "(2, 2, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1],[[2,2,0,0,0,0],[2,1,1,0,0,0],[2,1,0,1,0,0],[2,1,0,0,1,0],[2,1,0,0,0,1],[2,0,2,0,0,0],[2,0,1,1,0,0],[2,0,1,0,1,0],[2,0,1,0,0,1],[2,0,0,2,0,0],[2,0,0,1,1,0],[2,0,0,1,0,1],[2,0,0,0,2,0],[2,0,0,0,1,1],[2,0,0,0,0,2],[1,2,1,0,0,0],[1,2,0,1,0,0],[1,2,0,0,1,0],[1,2,0,0,0,1],[1,1,2,0,0,0],[1,1,1,1,0,0],[1,1,1,0,1,0],[1,1,1,0,0,1],[1,1,0,2,0,0],[1,1,0,1,1,0],[1,1,0,1,0,1],[1,1,0,0,2,0],[1,1,0,0,1,1],[1,1,0,0,0,2],[1,0,2,1,0,0],[1,0,2,0,1,0],[1,0,2,0,0,1],[1,0,1,2,0,0],[1,0,1,1,1,0],[1,0,1,1,0,1],[1,0,1,0,2,0],[1,0,1,0,1,1],[1,0,1,0,0,2],[1,0,0,2,1,0],[1,0,0,2,0,1],[1,0,0,1,2,0],[1,0,0,1,1,1],[1,0,0,1,0,2],[1,0,0,0,2,1],[1,0,0,0,1,2],[0,2,2,0,0,0],[0,2,1,1,0,0],[0,2,1,0,1,0],[0,2,1,0,0,1],[0,2,0,2,0,0],[0,2,0,1,1,0],[0,2,0,1,0,1],[0,2,0,0,2,0],[0,2,0,0,1,1],[0,2,0,0,0,2],[0,1,2,1,0,0],[0,1,2,0,1,0],[0,1,2,0,0,1],[0,1,1,2,0,0],[0,1,1,1,1,0],[0,1,1,1,0,1],[0,1,1,0,2,0],[0,1,1,0,1,1],[0,1,1,0,0,2],[0,1,0,2,1,0],[0,1,0,2,0,1],[0,1,0,1,2,0],[0,1,0,1,1,1],[0,1,0,1,0,2],[0,1,0,0,2,1],[0,1,0,0,1,2],[0,0,2,2,0,0],[0,0,2,1,1,0],[0,0,2,1,0,1],[0,0,2,0,2,0],[0,0,2,0,1,1],[0,0,2,0,0,2],[0,0,1,2,1,0],[0,0,1,2,0,1],[0,0,1,1,2,0],[0,0,1,1,1,1],[0,0,1,1,0,2],[0,0,1,0,2,1],[0,0,1,0,1,2],[0,0,0,2,2,0],[0,0,0,2,1,1],[0,0,0,2,0,2],[0,0,0,1,2,1],[0,0,0,1,1,2],[0,0,0,0,2,2]]], + "(2, 2, 1, 0, 0, 0)": [[1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,2,2,2,1,2,2,1,2,1,2,2,2,2,5,5,2,5,2,2,2,2,5,2,2,2,1,2,2,1,2,1,2,2,2,5,2,2,2,1,2,1,2,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,2,2,1,2,1,2,2,2,5,2,2,2,1,2,1,2,2,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1],[[2,2,1,0,0,0],[2,2,0,1,0,0],[2,2,0,0,1,0],[2,2,0,0,0,1],[2,1,2,0,0,0],[2,1,1,1,0,0],[2,1,1,0,1,0],[2,1,1,0,0,1],[2,1,0,2,0,0],[2,1,0,1,1,0],[2,1,0,1,0,1],[2,1,0,0,2,0],[2,1,0,0,1,1],[2,1,0,0,0,2],[2,0,2,1,0,0],[2,0,2,0,1,0],[2,0,2,0,0,1],[2,0,1,2,0,0],[2,0,1,1,1,0],[2,0,1,1,0,1],[2,0,1,0,2,0],[2,0,1,0,1,1],[2,0,1,0,0,2],[2,0,0,2,1,0],[2,0,0,2,0,1],[2,0,0,1,2,0],[2,0,0,1,1,1],[2,0,0,1,0,2],[2,0,0,0,2,1],[2,0,0,0,1,2],[1,2,2,0,0,0],[1,2,1,1,0,0],[1,2,1,0,1,0],[1,2,1,0,0,1],[1,2,0,2,0,0],[1,2,0,1,1,0],[1,2,0,1,0,1],[1,2,0,0,2,0],[1,2,0,0,1,1],[1,2,0,0,0,2],[1,1,2,1,0,0],[1,1,2,0,1,0],[1,1,2,0,0,1],[1,1,1,2,0,0],[1,1,1,1,1,0],[1,1,1,1,0,1],[1,1,1,0,2,0],[1,1,1,0,1,1],[1,1,1,0,0,2],[1,1,0,2,1,0],[1,1,0,2,0,1],[1,1,0,1,2,0],[1,1,0,1,1,1],[1,1,0,1,0,2],[1,1,0,0,2,1],[1,1,0,0,1,2],[1,0,2,2,0,0],[1,0,2,1,1,0],[1,0,2,1,0,1],[1,0,2,0,2,0],[1,0,2,0,1,1],[1,0,2,0,0,2],[1,0,1,2,1,0],[1,0,1,2,0,1],[1,0,1,1,2,0],[1,0,1,1,1,1],[1,0,1,1,0,2],[1,0,1,0,2,1],[1,0,1,0,1,2],[1,0,0,2,2,0],[1,0,0,2,1,1],[1,0,0,2,0,2],[1,0,0,1,2,1],[1,0,0,1,1,2],[1,0,0,0,2,2],[0,2,2,1,0,0],[0,2,2,0,1,0],[0,2,2,0,0,1],[0,2,1,2,0,0],[0,2,1,1,1,0],[0,2,1,1,0,1],[0,2,1,0,2,0],[0,2,1,0,1,1],[0,2,1,0,0,2],[0,2,0,2,1,0],[0,2,0,2,0,1],[0,2,0,1,2,0],[0,2,0,1,1,1],[0,2,0,1,0,2],[0,2,0,0,2,1],[0,2,0,0,1,2],[0,1,2,2,0,0],[0,1,2,1,1,0],[0,1,2,1,0,1],[0,1,2,0,2,0],[0,1,2,0,1,1],[0,1,2,0,0,2],[0,1,1,2,1,0],[0,1,1,2,0,1],[0,1,1,1,2,0],[0,1,1,1,1,1],[0,1,1,1,0,2],[0,1,1,0,2,1],[0,1,1,0,1,2],[0,1,0,2,2,0],[0,1,0,2,1,1],[0,1,0,2,0,2],[0,1,0,1,2,1],[0,1,0,1,1,2],[0,1,0,0,2,2],[0,0,2,2,1,0],[0,0,2,2,0,1],[0,0,2,1,2,0],[0,0,2,1,1,1],[0,0,2,1,0,2],[0,0,2,0,2,1],[0,0,2,0,1,2],[0,0,1,2,2,0],[0,0,1,2,1,1],[0,0,1,2,0,2],[0,0,1,1,2,1],[0,0,1,1,1,2],[0,0,1,0,2,2],[0,0,0,2,2,1],[0,0,0,2,1,2],[0,0,0,1,2,2]]], "(2, 2, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,3,3,1,3,1,3,3,3,9,3,3,3,1,3,1,3,3,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,1,1,1,1,1],[[2,2,1,1,0,0],[2,2,1,0,1,0],[2,2,1,0,0,1],[2,2,0,1,1,0],[2,2,0,1,0,1],[2,2,0,0,1,1],[2,1,2,1,0,0],[2,1,2,0,1,0],[2,1,2,0,0,1],[2,1,1,2,0,0],[2,1,1,1,1,0],[2,1,1,1,0,1],[2,1,1,0,2,0],[2,1,1,0,1,1],[2,1,1,0,0,2],[2,1,0,2,1,0],[2,1,0,2,0,1],[2,1,0,1,2,0],[2,1,0,1,1,1],[2,1,0,1,0,2],[2,1,0,0,2,1],[2,1,0,0,1,2],[2,0,2,1,1,0],[2,0,2,1,0,1],[2,0,2,0,1,1],[2,0,1,2,1,0],[2,0,1,2,0,1],[2,0,1,1,2,0],[2,0,1,1,1,1],[2,0,1,1,0,2],[2,0,1,0,2,1],[2,0,1,0,1,2],[2,0,0,2,1,1],[2,0,0,1,2,1],[2,0,0,1,1,2],[1,2,2,1,0,0],[1,2,2,0,1,0],[1,2,2,0,0,1],[1,2,1,2,0,0],[1,2,1,1,1,0],[1,2,1,1,0,1],[1,2,1,0,2,0],[1,2,1,0,1,1],[1,2,1,0,0,2],[1,2,0,2,1,0],[1,2,0,2,0,1],[1,2,0,1,2,0],[1,2,0,1,1,1],[1,2,0,1,0,2],[1,2,0,0,2,1],[1,2,0,0,1,2],[1,1,2,2,0,0],[1,1,2,1,1,0],[1,1,2,1,0,1],[1,1,2,0,2,0],[1,1,2,0,1,1],[1,1,2,0,0,2],[1,1,1,2,1,0],[1,1,1,2,0,1],[1,1,1,1,2,0],[1,1,1,1,1,1],[1,1,1,1,0,2],[1,1,1,0,2,1],[1,1,1,0,1,2],[1,1,0,2,2,0],[1,1,0,2,1,1],[1,1,0,2,0,2],[1,1,0,1,2,1],[1,1,0,1,1,2],[1,1,0,0,2,2],[1,0,2,2,1,0],[1,0,2,2,0,1],[1,0,2,1,2,0],[1,0,2,1,1,1],[1,0,2,1,0,2],[1,0,2,0,2,1],[1,0,2,0,1,2],[1,0,1,2,2,0],[1,0,1,2,1,1],[1,0,1,2,0,2],[1,0,1,1,2,1],[1,0,1,1,1,2],[1,0,1,0,2,2],[1,0,0,2,2,1],[1,0,0,2,1,2],[1,0,0,1,2,2],[0,2,2,1,1,0],[0,2,2,1,0,1],[0,2,2,0,1,1],[0,2,1,2,1,0],[0,2,1,2,0,1],[0,2,1,1,2,0],[0,2,1,1,1,1],[0,2,1,1,0,2],[0,2,1,0,2,1],[0,2,1,0,1,2],[0,2,0,2,1,1],[0,2,0,1,2,1],[0,2,0,1,1,2],[0,1,2,2,1,0],[0,1,2,2,0,1],[0,1,2,1,2,0],[0,1,2,1,1,1],[0,1,2,1,0,2],[0,1,2,0,2,1],[0,1,2,0,1,2],[0,1,1,2,2,0],[0,1,1,2,1,1],[0,1,1,2,0,2],[0,1,1,1,2,1],[0,1,1,1,1,2],[0,1,1,0,2,2],[0,1,0,2,2,1],[0,1,0,2,1,2],[0,1,0,1,2,2],[0,0,2,2,1,1],[0,0,2,1,2,1],[0,0,2,1,1,2],[0,0,1,2,2,1],[0,0,1,2,1,2],[0,0,1,1,2,2]]], "(2, 2, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,1,1,1,0],[2,2,1,1,0,1],[2,2,1,0,1,1],[2,2,0,1,1,1],[2,1,2,1,1,0],[2,1,2,1,0,1],[2,1,2,0,1,1],[2,1,1,2,1,0],[2,1,1,2,0,1],[2,1,1,1,2,0],[2,1,1,1,1,1],[2,1,1,1,0,2],[2,1,1,0,2,1],[2,1,1,0,1,2],[2,1,0,2,1,1],[2,1,0,1,2,1],[2,1,0,1,1,2],[2,0,2,1,1,1],[2,0,1,2,1,1],[2,0,1,1,2,1],[2,0,1,1,1,2],[1,2,2,1,1,0],[1,2,2,1,0,1],[1,2,2,0,1,1],[1,2,1,2,1,0],[1,2,1,2,0,1],[1,2,1,1,2,0],[1,2,1,1,1,1],[1,2,1,1,0,2],[1,2,1,0,2,1],[1,2,1,0,1,2],[1,2,0,2,1,1],[1,2,0,1,2,1],[1,2,0,1,1,2],[1,1,2,2,1,0],[1,1,2,2,0,1],[1,1,2,1,2,0],[1,1,2,1,1,1],[1,1,2,1,0,2],[1,1,2,0,2,1],[1,1,2,0,1,2],[1,1,1,2,2,0],[1,1,1,2,1,1],[1,1,1,2,0,2],[1,1,1,1,2,1],[1,1,1,1,1,2],[1,1,1,0,2,2],[1,1,0,2,2,1],[1,1,0,2,1,2],[1,1,0,1,2,2],[1,0,2,2,1,1],[1,0,2,1,2,1],[1,0,2,1,1,2],[1,0,1,2,2,1],[1,0,1,2,1,2],[1,0,1,1,2,2],[0,2,2,1,1,1],[0,2,1,2,1,1],[0,2,1,1,2,1],[0,2,1,1,1,2],[0,1,2,2,1,1],[0,1,2,1,2,1],[0,1,2,1,1,2],[0,1,1,2,2,1],[0,1,1,2,1,2],[0,1,1,1,2,2]]], + "(2, 2, 2, 1, 0, 0)": [[1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,2,2,1,2,1,2,2,2,5,2,2,2,1,2,1,2,2,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,2,1,2,1,2,2,2,5,2,2,2,1,2,1,2,2,1,2,2,2,5,2,2,2,2,5,2,5,5,2,2,2,2,1,2,1,2,2,1,2,2,2,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1],[[2,2,2,1,0,0],[2,2,2,0,1,0],[2,2,2,0,0,1],[2,2,1,2,0,0],[2,2,1,1,1,0],[2,2,1,1,0,1],[2,2,1,0,2,0],[2,2,1,0,1,1],[2,2,1,0,0,2],[2,2,0,2,1,0],[2,2,0,2,0,1],[2,2,0,1,2,0],[2,2,0,1,1,1],[2,2,0,1,0,2],[2,2,0,0,2,1],[2,2,0,0,1,2],[2,1,2,2,0,0],[2,1,2,1,1,0],[2,1,2,1,0,1],[2,1,2,0,2,0],[2,1,2,0,1,1],[2,1,2,0,0,2],[2,1,1,2,1,0],[2,1,1,2,0,1],[2,1,1,1,2,0],[2,1,1,1,1,1],[2,1,1,1,0,2],[2,1,1,0,2,1],[2,1,1,0,1,2],[2,1,0,2,2,0],[2,1,0,2,1,1],[2,1,0,2,0,2],[2,1,0,1,2,1],[2,1,0,1,1,2],[2,1,0,0,2,2],[2,0,2,2,1,0],[2,0,2,2,0,1],[2,0,2,1,2,0],[2,0,2,1,1,1],[2,0,2,1,0,2],[2,0,2,0,2,1],[2,0,2,0,1,2],[2,0,1,2,2,0],[2,0,1,2,1,1],[2,0,1,2,0,2],[2,0,1,1,2,1],[2,0,1,1,1,2],[2,0,1,0,2,2],[2,0,0,2,2,1],[2,0,0,2,1,2],[2,0,0,1,2,2],[1,2,2,2,0,0],[1,2,2,1,1,0],[1,2,2,1,0,1],[1,2,2,0,2,0],[1,2,2,0,1,1],[1,2,2,0,0,2],[1,2,1,2,1,0],[1,2,1,2,0,1],[1,2,1,1,2,0],[1,2,1,1,1,1],[1,2,1,1,0,2],[1,2,1,0,2,1],[1,2,1,0,1,2],[1,2,0,2,2,0],[1,2,0,2,1,1],[1,2,0,2,0,2],[1,2,0,1,2,1],[1,2,0,1,1,2],[1,2,0,0,2,2],[1,1,2,2,1,0],[1,1,2,2,0,1],[1,1,2,1,2,0],[1,1,2,1,1,1],[1,1,2,1,0,2],[1,1,2,0,2,1],[1,1,2,0,1,2],[1,1,1,2,2,0],[1,1,1,2,1,1],[1,1,1,2,0,2],[1,1,1,1,2,1],[1,1,1,1,1,2],[1,1,1,0,2,2],[1,1,0,2,2,1],[1,1,0,2,1,2],[1,1,0,1,2,2],[1,0,2,2,2,0],[1,0,2,2,1,1],[1,0,2,2,0,2],[1,0,2,1,2,1],[1,0,2,1,1,2],[1,0,2,0,2,2],[1,0,1,2,2,1],[1,0,1,2,1,2],[1,0,1,1,2,2],[1,0,0,2,2,2],[0,2,2,2,1,0],[0,2,2,2,0,1],[0,2,2,1,2,0],[0,2,2,1,1,1],[0,2,2,1,0,2],[0,2,2,0,2,1],[0,2,2,0,1,2],[0,2,1,2,2,0],[0,2,1,2,1,1],[0,2,1,2,0,2],[0,2,1,1,2,1],[0,2,1,1,1,2],[0,2,1,0,2,2],[0,2,0,2,2,1],[0,2,0,2,1,2],[0,2,0,1,2,2],[0,1,2,2,2,0],[0,1,2,2,1,1],[0,1,2,2,0,2],[0,1,2,1,2,1],[0,1,2,1,1,2],[0,1,2,0,2,2],[0,1,1,2,2,1],[0,1,1,2,1,2],[0,1,1,1,2,2],[0,1,0,2,2,2],[0,0,2,2,2,1],[0,0,2,2,1,2],[0,0,2,1,2,2],[0,0,1,2,2,2]]], "(2, 2, 2, 1, 1, 0)": [[1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,3,1,3,3,1,3,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,1,1,0],[2,2,2,1,0,1],[2,2,2,0,1,1],[2,2,1,2,1,0],[2,2,1,2,0,1],[2,2,1,1,2,0],[2,2,1,1,1,1],[2,2,1,1,0,2],[2,2,1,0,2,1],[2,2,1,0,1,2],[2,2,0,2,1,1],[2,2,0,1,2,1],[2,2,0,1,1,2],[2,1,2,2,1,0],[2,1,2,2,0,1],[2,1,2,1,2,0],[2,1,2,1,1,1],[2,1,2,1,0,2],[2,1,2,0,2,1],[2,1,2,0,1,2],[2,1,1,2,2,0],[2,1,1,2,1,1],[2,1,1,2,0,2],[2,1,1,1,2,1],[2,1,1,1,1,2],[2,1,1,0,2,2],[2,1,0,2,2,1],[2,1,0,2,1,2],[2,1,0,1,2,2],[2,0,2,2,1,1],[2,0,2,1,2,1],[2,0,2,1,1,2],[2,0,1,2,2,1],[2,0,1,2,1,2],[2,0,1,1,2,2],[1,2,2,2,1,0],[1,2,2,2,0,1],[1,2,2,1,2,0],[1,2,2,1,1,1],[1,2,2,1,0,2],[1,2,2,0,2,1],[1,2,2,0,1,2],[1,2,1,2,2,0],[1,2,1,2,1,1],[1,2,1,2,0,2],[1,2,1,1,2,1],[1,2,1,1,1,2],[1,2,1,0,2,2],[1,2,0,2,2,1],[1,2,0,2,1,2],[1,2,0,1,2,2],[1,1,2,2,2,0],[1,1,2,2,1,1],[1,1,2,2,0,2],[1,1,2,1,2,1],[1,1,2,1,1,2],[1,1,2,0,2,2],[1,1,1,2,2,1],[1,1,1,2,1,2],[1,1,1,1,2,2],[1,1,0,2,2,2],[1,0,2,2,2,1],[1,0,2,2,1,2],[1,0,2,1,2,2],[1,0,1,2,2,2],[0,2,2,2,1,1],[0,2,2,1,2,1],[0,2,2,1,1,2],[0,2,1,2,2,1],[0,2,1,2,1,2],[0,2,1,1,2,2],[0,1,2,2,2,1],[0,1,2,2,1,2],[0,1,2,1,2,2],[0,1,1,2,2,2]]], "(2, 2, 2, 2, 0, 0)": [[1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,0,0],[2,2,2,1,1,0],[2,2,2,1,0,1],[2,2,2,0,2,0],[2,2,2,0,1,1],[2,2,2,0,0,2],[2,2,1,2,1,0],[2,2,1,2,0,1],[2,2,1,1,2,0],[2,2,1,1,1,1],[2,2,1,1,0,2],[2,2,1,0,2,1],[2,2,1,0,1,2],[2,2,0,2,2,0],[2,2,0,2,1,1],[2,2,0,2,0,2],[2,2,0,1,2,1],[2,2,0,1,1,2],[2,2,0,0,2,2],[2,1,2,2,1,0],[2,1,2,2,0,1],[2,1,2,1,2,0],[2,1,2,1,1,1],[2,1,2,1,0,2],[2,1,2,0,2,1],[2,1,2,0,1,2],[2,1,1,2,2,0],[2,1,1,2,1,1],[2,1,1,2,0,2],[2,1,1,1,2,1],[2,1,1,1,1,2],[2,1,1,0,2,2],[2,1,0,2,2,1],[2,1,0,2,1,2],[2,1,0,1,2,2],[2,0,2,2,2,0],[2,0,2,2,1,1],[2,0,2,2,0,2],[2,0,2,1,2,1],[2,0,2,1,1,2],[2,0,2,0,2,2],[2,0,1,2,2,1],[2,0,1,2,1,2],[2,0,1,1,2,2],[2,0,0,2,2,2],[1,2,2,2,1,0],[1,2,2,2,0,1],[1,2,2,1,2,0],[1,2,2,1,1,1],[1,2,2,1,0,2],[1,2,2,0,2,1],[1,2,2,0,1,2],[1,2,1,2,2,0],[1,2,1,2,1,1],[1,2,1,2,0,2],[1,2,1,1,2,1],[1,2,1,1,1,2],[1,2,1,0,2,2],[1,2,0,2,2,1],[1,2,0,2,1,2],[1,2,0,1,2,2],[1,1,2,2,2,0],[1,1,2,2,1,1],[1,1,2,2,0,2],[1,1,2,1,2,1],[1,1,2,1,1,2],[1,1,2,0,2,2],[1,1,1,2,2,1],[1,1,1,2,1,2],[1,1,1,1,2,2],[1,1,0,2,2,2],[1,0,2,2,2,1],[1,0,2,2,1,2],[1,0,2,1,2,2],[1,0,1,2,2,2],[0,2,2,2,2,0],[0,2,2,2,1,1],[0,2,2,2,0,2],[0,2,2,1,2,1],[0,2,2,1,1,2],[0,2,2,0,2,2],[0,2,1,2,2,1],[0,2,1,2,1,2],[0,2,1,1,2,2],[0,2,0,2,2,2],[0,1,2,2,2,1],[0,1,2,2,1,2],[0,1,2,1,2,2],[0,1,1,2,2,2],[0,0,2,2,2,2]]], "(2, 2, 2, 2, 1, 0)": [[1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,1,1,1,1,1],[[2,2,2,2,1,0],[2,2,2,2,0,1],[2,2,2,1,2,0],[2,2,2,1,1,1],[2,2,2,1,0,2],[2,2,2,0,2,1],[2,2,2,0,1,2],[2,2,1,2,2,0],[2,2,1,2,1,1],[2,2,1,2,0,2],[2,2,1,1,2,1],[2,2,1,1,1,2],[2,2,1,0,2,2],[2,2,0,2,2,1],[2,2,0,2,1,2],[2,2,0,1,2,2],[2,1,2,2,2,0],[2,1,2,2,1,1],[2,1,2,2,0,2],[2,1,2,1,2,1],[2,1,2,1,1,2],[2,1,2,0,2,2],[2,1,1,2,2,1],[2,1,1,2,1,2],[2,1,1,1,2,2],[2,1,0,2,2,2],[2,0,2,2,2,1],[2,0,2,2,1,2],[2,0,2,1,2,2],[2,0,1,2,2,2],[1,2,2,2,2,0],[1,2,2,2,1,1],[1,2,2,2,0,2],[1,2,2,1,2,1],[1,2,2,1,1,2],[1,2,2,0,2,2],[1,2,1,2,2,1],[1,2,1,2,1,2],[1,2,1,1,2,2],[1,2,0,2,2,2],[1,1,2,2,2,1],[1,1,2,2,1,2],[1,1,2,1,2,2],[1,1,1,2,2,2],[1,0,2,2,2,2],[0,2,2,2,2,1],[0,2,2,2,1,2],[0,2,2,1,2,2],[0,2,1,2,2,2],[0,1,2,2,2,2]]], "(2, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,2,0],[2,2,2,2,1,1],[2,2,2,2,0,2],[2,2,2,1,2,1],[2,2,2,1,1,2],[2,2,2,0,2,2],[2,2,1,2,2,1],[2,2,1,2,1,2],[2,2,1,1,2,2],[2,2,0,2,2,2],[2,1,2,2,2,1],[2,1,2,2,1,2],[2,1,2,1,2,2],[2,1,1,2,2,2],[2,0,2,2,2,2],[1,2,2,2,2,1],[1,2,2,2,1,2],[1,2,2,1,2,2],[1,2,1,2,2,2],[1,1,2,2,2,2],[0,2,2,2,2,2]]], + "(3, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,0,0,0,0,0],[2,1,0,0,0,0],[2,0,1,0,0,0],[2,0,0,1,0,0],[2,0,0,0,1,0],[2,0,0,0,0,1],[1,2,0,0,0,0],[1,1,1,0,0,0],[1,1,0,1,0,0],[1,1,0,0,1,0],[1,1,0,0,0,1],[1,0,2,0,0,0],[1,0,1,1,0,0],[1,0,1,0,1,0],[1,0,1,0,0,1],[1,0,0,2,0,0],[1,0,0,1,1,0],[1,0,0,1,0,1],[1,0,0,0,2,0],[1,0,0,0,1,1],[1,0,0,0,0,2],[0,3,0,0,0,0],[0,2,1,0,0,0],[0,2,0,1,0,0],[0,2,0,0,1,0],[0,2,0,0,0,1],[0,1,2,0,0,0],[0,1,1,1,0,0],[0,1,1,0,1,0],[0,1,1,0,0,1],[0,1,0,2,0,0],[0,1,0,1,1,0],[0,1,0,1,0,1],[0,1,0,0,2,0],[0,1,0,0,1,1],[0,1,0,0,0,2],[0,0,3,0,0,0],[0,0,2,1,0,0],[0,0,2,0,1,0],[0,0,2,0,0,1],[0,0,1,2,0,0],[0,0,1,1,1,0],[0,0,1,1,0,1],[0,0,1,0,2,0],[0,0,1,0,1,1],[0,0,1,0,0,2],[0,0,0,3,0,0],[0,0,0,2,1,0],[0,0,0,2,0,1],[0,0,0,1,2,0],[0,0,0,1,1,1],[0,0,0,1,0,2],[0,0,0,0,3,0],[0,0,0,0,2,1],[0,0,0,0,1,2],[0,0,0,0,0,3]]], "(3, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,5,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,1,1,1,1,0],[3,1,1,1,0,1],[3,1,1,0,1,1],[3,1,0,1,1,1],[3,0,1,1,1,1],[2,2,1,1,1,0],[2,2,1,1,0,1],[2,2,1,0,1,1],[2,2,0,1,1,1],[2,1,2,1,1,0],[2,1,2,1,0,1],[2,1,2,0,1,1],[2,1,1,2,1,0],[2,1,1,2,0,1],[2,1,1,1,2,0],[2,1,1,1,1,1],[2,1,1,1,0,2],[2,1,1,0,2,1],[2,1,1,0,1,2],[2,1,0,2,1,1],[2,1,0,1,2,1],[2,1,0,1,1,2],[2,0,2,1,1,1],[2,0,1,2,1,1],[2,0,1,1,2,1],[2,0,1,1,1,2],[1,3,1,1,1,0],[1,3,1,1,0,1],[1,3,1,0,1,1],[1,3,0,1,1,1],[1,2,2,1,1,0],[1,2,2,1,0,1],[1,2,2,0,1,1],[1,2,1,2,1,0],[1,2,1,2,0,1],[1,2,1,1,2,0],[1,2,1,1,1,1],[1,2,1,1,0,2],[1,2,1,0,2,1],[1,2,1,0,1,2],[1,2,0,2,1,1],[1,2,0,1,2,1],[1,2,0,1,1,2],[1,1,3,1,1,0],[1,1,3,1,0,1],[1,1,3,0,1,1],[1,1,2,2,1,0],[1,1,2,2,0,1],[1,1,2,1,2,0],[1,1,2,1,1,1],[1,1,2,1,0,2],[1,1,2,0,2,1],[1,1,2,0,1,2],[1,1,1,3,1,0],[1,1,1,3,0,1],[1,1,1,2,2,0],[1,1,1,2,1,1],[1,1,1,2,0,2],[1,1,1,1,3,0],[1,1,1,1,2,1],[1,1,1,1,1,2],[1,1,1,1,0,3],[1,1,1,0,3,1],[1,1,1,0,2,2],[1,1,1,0,1,3],[1,1,0,3,1,1],[1,1,0,2,2,1],[1,1,0,2,1,2],[1,1,0,1,3,1],[1,1,0,1,2,2],[1,1,0,1,1,3],[1,0,3,1,1,1],[1,0,2,2,1,1],[1,0,2,1,2,1],[1,0,2,1,1,2],[1,0,1,3,1,1],[1,0,1,2,2,1],[1,0,1,2,1,2],[1,0,1,1,3,1],[1,0,1,1,2,2],[1,0,1,1,1,3],[0,3,1,1,1,1],[0,2,2,1,1,1],[0,2,1,2,1,1],[0,2,1,1,2,1],[0,2,1,1,1,2],[0,1,3,1,1,1],[0,1,2,2,1,1],[0,1,2,1,2,1],[0,1,2,1,1,2],[0,1,1,3,1,1],[0,1,1,2,2,1],[0,1,1,2,1,2],[0,1,1,1,3,1],[0,1,1,1,2,2],[0,1,1,1,1,3]]], - "(3, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,2,2,2,2,0],[3,2,2,2,1,1],[3,2,2,2,0,2],[3,2,2,1,2,1],[3,2,2,1,1,2],[3,2,2,0,2,2],[3,2,1,2,2,1],[3,2,1,2,1,2],[3,2,1,1,2,2],[3,2,0,2,2,2],[3,1,2,2,2,1],[3,1,2,2,1,2],[3,1,2,1,2,2],[3,1,1,2,2,2],[3,0,2,2,2,2],[2,3,2,2,2,0],[2,3,2,2,1,1],[2,3,2,2,0,2],[2,3,2,1,2,1],[2,3,2,1,1,2],[2,3,2,0,2,2],[2,3,1,2,2,1],[2,3,1,2,1,2],[2,3,1,1,2,2],[2,3,0,2,2,2],[2,2,3,2,2,0],[2,2,3,2,1,1],[2,2,3,2,0,2],[2,2,3,1,2,1],[2,2,3,1,1,2],[2,2,3,0,2,2],[2,2,2,3,2,0],[2,2,2,3,1,1],[2,2,2,3,0,2],[2,2,2,2,3,0],[2,2,2,2,2,1],[2,2,2,2,1,2],[2,2,2,2,0,3],[2,2,2,1,3,1],[2,2,2,1,2,2],[2,2,2,1,1,3],[2,2,2,0,3,2],[2,2,2,0,2,3],[2,2,1,3,2,1],[2,2,1,3,1,2],[2,2,1,2,3,1],[2,2,1,2,2,2],[2,2,1,2,1,3],[2,2,1,1,3,2],[2,2,1,1,2,3],[2,2,0,3,2,2],[2,2,0,2,3,2],[2,2,0,2,2,3],[2,1,3,2,2,1],[2,1,3,2,1,2],[2,1,3,1,2,2],[2,1,2,3,2,1],[2,1,2,3,1,2],[2,1,2,2,3,1],[2,1,2,2,2,2],[2,1,2,2,1,3],[2,1,2,1,3,2],[2,1,2,1,2,3],[2,1,1,3,2,2],[2,1,1,2,3,2],[2,1,1,2,2,3],[2,0,3,2,2,2],[2,0,2,3,2,2],[2,0,2,2,3,2],[2,0,2,2,2,3],[1,3,2,2,2,1],[1,3,2,2,1,2],[1,3,2,1,2,2],[1,3,1,2,2,2],[1,2,3,2,2,1],[1,2,3,2,1,2],[1,2,3,1,2,2],[1,2,2,3,2,1],[1,2,2,3,1,2],[1,2,2,2,3,1],[1,2,2,2,2,2],[1,2,2,2,1,3],[1,2,2,1,3,2],[1,2,2,1,2,3],[1,2,1,3,2,2],[1,2,1,2,3,2],[1,2,1,2,2,3],[1,1,3,2,2,2],[1,1,2,3,2,2],[1,1,2,2,3,2],[1,1,2,2,2,3],[0,3,2,2,2,2],[0,2,3,2,2,2],[0,2,2,3,2,2],[0,2,2,2,3,2],[0,2,2,2,2,3]]] + "(3, 2, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,8,2,2,2,2,2,2,1,1,1,2,2,2,8,2,2,2,1,1,2,8,2,1,8,8,1,1,2,1,1,2,2,1,2,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,2,2,2,8,2,2,2,1,1,2,8,2,1,8,8,1,1,2,1,1,2,2,1,2,1,1,1,1,4,1,1,1,1,1,2,8,2,1,8,8,1,1,2,1,1,4,1,1,8,8,1,4,8,4,1,1,1,1,1,2,1,1,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1],[[3,2,1,1,1,0],[3,2,1,1,0,1],[3,2,1,0,1,1],[3,2,0,1,1,1],[3,1,2,1,1,0],[3,1,2,1,0,1],[3,1,2,0,1,1],[3,1,1,2,1,0],[3,1,1,2,0,1],[3,1,1,1,2,0],[3,1,1,1,1,1],[3,1,1,1,0,2],[3,1,1,0,2,1],[3,1,1,0,1,2],[3,1,0,2,1,1],[3,1,0,1,2,1],[3,1,0,1,1,2],[3,0,2,1,1,1],[3,0,1,2,1,1],[3,0,1,1,2,1],[3,0,1,1,1,2],[2,3,1,1,1,0],[2,3,1,1,0,1],[2,3,1,0,1,1],[2,3,0,1,1,1],[2,2,2,1,1,0],[2,2,2,1,0,1],[2,2,2,0,1,1],[2,2,1,2,1,0],[2,2,1,2,0,1],[2,2,1,1,2,0],[2,2,1,1,1,1],[2,2,1,1,0,2],[2,2,1,0,2,1],[2,2,1,0,1,2],[2,2,0,2,1,1],[2,2,0,1,2,1],[2,2,0,1,1,2],[2,1,3,1,1,0],[2,1,3,1,0,1],[2,1,3,0,1,1],[2,1,2,2,1,0],[2,1,2,2,0,1],[2,1,2,1,2,0],[2,1,2,1,1,1],[2,1,2,1,0,2],[2,1,2,0,2,1],[2,1,2,0,1,2],[2,1,1,3,1,0],[2,1,1,3,0,1],[2,1,1,2,2,0],[2,1,1,2,1,1],[2,1,1,2,0,2],[2,1,1,1,3,0],[2,1,1,1,2,1],[2,1,1,1,1,2],[2,1,1,1,0,3],[2,1,1,0,3,1],[2,1,1,0,2,2],[2,1,1,0,1,3],[2,1,0,3,1,1],[2,1,0,2,2,1],[2,1,0,2,1,2],[2,1,0,1,3,1],[2,1,0,1,2,2],[2,1,0,1,1,3],[2,0,3,1,1,1],[2,0,2,2,1,1],[2,0,2,1,2,1],[2,0,2,1,1,2],[2,0,1,3,1,1],[2,0,1,2,2,1],[2,0,1,2,1,2],[2,0,1,1,3,1],[2,0,1,1,2,2],[2,0,1,1,1,3],[1,3,2,1,1,0],[1,3,2,1,0,1],[1,3,2,0,1,1],[1,3,1,2,1,0],[1,3,1,2,0,1],[1,3,1,1,2,0],[1,3,1,1,1,1],[1,3,1,1,0,2],[1,3,1,0,2,1],[1,3,1,0,1,2],[1,3,0,2,1,1],[1,3,0,1,2,1],[1,3,0,1,1,2],[1,2,3,1,1,0],[1,2,3,1,0,1],[1,2,3,0,1,1],[1,2,2,2,1,0],[1,2,2,2,0,1],[1,2,2,1,2,0],[1,2,2,1,1,1],[1,2,2,1,0,2],[1,2,2,0,2,1],[1,2,2,0,1,2],[1,2,1,3,1,0],[1,2,1,3,0,1],[1,2,1,2,2,0],[1,2,1,2,1,1],[1,2,1,2,0,2],[1,2,1,1,3,0],[1,2,1,1,2,1],[1,2,1,1,1,2],[1,2,1,1,0,3],[1,2,1,0,3,1],[1,2,1,0,2,2],[1,2,1,0,1,3],[1,2,0,3,1,1],[1,2,0,2,2,1],[1,2,0,2,1,2],[1,2,0,1,3,1],[1,2,0,1,2,2],[1,2,0,1,1,3],[1,1,3,2,1,0],[1,1,3,2,0,1],[1,1,3,1,2,0],[1,1,3,1,1,1],[1,1,3,1,0,2],[1,1,3,0,2,1],[1,1,3,0,1,2],[1,1,2,3,1,0],[1,1,2,3,0,1],[1,1,2,2,2,0],[1,1,2,2,1,1],[1,1,2,2,0,2],[1,1,2,1,3,0],[1,1,2,1,2,1],[1,1,2,1,1,2],[1,1,2,1,0,3],[1,1,2,0,3,1],[1,1,2,0,2,2],[1,1,2,0,1,3],[1,1,1,3,2,0],[1,1,1,3,1,1],[1,1,1,3,0,2],[1,1,1,2,3,0],[1,1,1,2,2,1],[1,1,1,2,1,2],[1,1,1,2,0,3],[1,1,1,1,3,1],[1,1,1,1,2,2],[1,1,1,1,1,3],[1,1,1,0,3,2],[1,1,1,0,2,3],[1,1,0,3,2,1],[1,1,0,3,1,2],[1,1,0,2,3,1],[1,1,0,2,2,2],[1,1,0,2,1,3],[1,1,0,1,3,2],[1,1,0,1,2,3],[1,0,3,2,1,1],[1,0,3,1,2,1],[1,0,3,1,1,2],[1,0,2,3,1,1],[1,0,2,2,2,1],[1,0,2,2,1,2],[1,0,2,1,3,1],[1,0,2,1,2,2],[1,0,2,1,1,3],[1,0,1,3,2,1],[1,0,1,3,1,2],[1,0,1,2,3,1],[1,0,1,2,2,2],[1,0,1,2,1,3],[1,0,1,1,3,2],[1,0,1,1,2,3],[0,3,2,1,1,1],[0,3,1,2,1,1],[0,3,1,1,2,1],[0,3,1,1,1,2],[0,2,3,1,1,1],[0,2,2,2,1,1],[0,2,2,1,2,1],[0,2,2,1,1,2],[0,2,1,3,1,1],[0,2,1,2,2,1],[0,2,1,2,1,2],[0,2,1,1,3,1],[0,2,1,1,2,2],[0,2,1,1,1,3],[0,1,3,2,1,1],[0,1,3,1,2,1],[0,1,3,1,1,2],[0,1,2,3,1,1],[0,1,2,2,2,1],[0,1,2,2,1,2],[0,1,2,1,3,1],[0,1,2,1,2,2],[0,1,2,1,1,3],[0,1,1,3,2,1],[0,1,1,3,1,2],[0,1,1,2,3,1],[0,1,1,2,2,2],[0,1,1,2,1,3],[0,1,1,1,3,2],[0,1,1,1,2,3]]], + "(3, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,2,2,2,2,0],[3,2,2,2,1,1],[3,2,2,2,0,2],[3,2,2,1,2,1],[3,2,2,1,1,2],[3,2,2,0,2,2],[3,2,1,2,2,1],[3,2,1,2,1,2],[3,2,1,1,2,2],[3,2,0,2,2,2],[3,1,2,2,2,1],[3,1,2,2,1,2],[3,1,2,1,2,2],[3,1,1,2,2,2],[3,0,2,2,2,2],[2,3,2,2,2,0],[2,3,2,2,1,1],[2,3,2,2,0,2],[2,3,2,1,2,1],[2,3,2,1,1,2],[2,3,2,0,2,2],[2,3,1,2,2,1],[2,3,1,2,1,2],[2,3,1,1,2,2],[2,3,0,2,2,2],[2,2,3,2,2,0],[2,2,3,2,1,1],[2,2,3,2,0,2],[2,2,3,1,2,1],[2,2,3,1,1,2],[2,2,3,0,2,2],[2,2,2,3,2,0],[2,2,2,3,1,1],[2,2,2,3,0,2],[2,2,2,2,3,0],[2,2,2,2,2,1],[2,2,2,2,1,2],[2,2,2,2,0,3],[2,2,2,1,3,1],[2,2,2,1,2,2],[2,2,2,1,1,3],[2,2,2,0,3,2],[2,2,2,0,2,3],[2,2,1,3,2,1],[2,2,1,3,1,2],[2,2,1,2,3,1],[2,2,1,2,2,2],[2,2,1,2,1,3],[2,2,1,1,3,2],[2,2,1,1,2,3],[2,2,0,3,2,2],[2,2,0,2,3,2],[2,2,0,2,2,3],[2,1,3,2,2,1],[2,1,3,2,1,2],[2,1,3,1,2,2],[2,1,2,3,2,1],[2,1,2,3,1,2],[2,1,2,2,3,1],[2,1,2,2,2,2],[2,1,2,2,1,3],[2,1,2,1,3,2],[2,1,2,1,2,3],[2,1,1,3,2,2],[2,1,1,2,3,2],[2,1,1,2,2,3],[2,0,3,2,2,2],[2,0,2,3,2,2],[2,0,2,2,3,2],[2,0,2,2,2,3],[1,3,2,2,2,1],[1,3,2,2,1,2],[1,3,2,1,2,2],[1,3,1,2,2,2],[1,2,3,2,2,1],[1,2,3,2,1,2],[1,2,3,1,2,2],[1,2,2,3,2,1],[1,2,2,3,1,2],[1,2,2,2,3,1],[1,2,2,2,2,2],[1,2,2,2,1,3],[1,2,2,1,3,2],[1,2,2,1,2,3],[1,2,1,3,2,2],[1,2,1,2,3,2],[1,2,1,2,2,3],[1,1,3,2,2,2],[1,1,2,3,2,2],[1,1,2,2,3,2],[1,1,2,2,2,3],[0,3,2,2,2,2],[0,2,3,2,2,2],[0,2,2,3,2,2],[0,2,2,2,3,2],[0,2,2,2,2,3]]], + "(3, 3, 3, 3, 3, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,3,3,3,3,0],[3,3,3,3,2,1],[3,3,3,3,1,2],[3,3,3,3,0,3],[3,3,3,2,3,1],[3,3,3,2,2,2],[3,3,3,2,1,3],[3,3,3,1,3,2],[3,3,3,1,2,3],[3,3,3,0,3,3],[3,3,2,3,3,1],[3,3,2,3,2,2],[3,3,2,3,1,3],[3,3,2,2,3,2],[3,3,2,2,2,3],[3,3,2,1,3,3],[3,3,1,3,3,2],[3,3,1,3,2,3],[3,3,1,2,3,3],[3,3,0,3,3,3],[3,2,3,3,3,1],[3,2,3,3,2,2],[3,2,3,3,1,3],[3,2,3,2,3,2],[3,2,3,2,2,3],[3,2,3,1,3,3],[3,2,2,3,3,2],[3,2,2,3,2,3],[3,2,2,2,3,3],[3,2,1,3,3,3],[3,1,3,3,3,2],[3,1,3,3,2,3],[3,1,3,2,3,3],[3,1,2,3,3,3],[3,0,3,3,3,3],[2,3,3,3,3,1],[2,3,3,3,2,2],[2,3,3,3,1,3],[2,3,3,2,3,2],[2,3,3,2,2,3],[2,3,3,1,3,3],[2,3,2,3,3,2],[2,3,2,3,2,3],[2,3,2,2,3,3],[2,3,1,3,3,3],[2,2,3,3,3,2],[2,2,3,3,2,3],[2,2,3,2,3,3],[2,2,2,3,3,3],[2,1,3,3,3,3],[1,3,3,3,3,2],[1,3,3,3,2,3],[1,3,3,2,3,3],[1,3,2,3,3,3],[1,2,3,3,3,3],[0,3,3,3,3,3]]] + }, + "SU(7)": { + "(0, 0, 0, 0, 0, 0, 0)": [[1],[[0,0,0,0,0,0,0]]], + "(1, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1],[[1,0,0,0,0,0,0],[0,1,0,0,0,0,0],[0,0,1,0,0,0,0],[0,0,0,1,0,0,0],[0,0,0,0,1,0,0],[0,0,0,0,0,1,0],[0,0,0,0,0,0,1]]], + "(1, 1, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,0,0,0,0,0],[1,0,1,0,0,0,0],[1,0,0,1,0,0,0],[1,0,0,0,1,0,0],[1,0,0,0,0,1,0],[1,0,0,0,0,0,1],[0,1,1,0,0,0,0],[0,1,0,1,0,0,0],[0,1,0,0,1,0,0],[0,1,0,0,0,1,0],[0,1,0,0,0,0,1],[0,0,1,1,0,0,0],[0,0,1,0,1,0,0],[0,0,1,0,0,1,0],[0,0,1,0,0,0,1],[0,0,0,1,1,0,0],[0,0,0,1,0,1,0],[0,0,0,1,0,0,1],[0,0,0,0,1,1,0],[0,0,0,0,1,0,1],[0,0,0,0,0,1,1]]], + "(1, 1, 1, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,0,0,0,0],[1,1,0,1,0,0,0],[1,1,0,0,1,0,0],[1,1,0,0,0,1,0],[1,1,0,0,0,0,1],[1,0,1,1,0,0,0],[1,0,1,0,1,0,0],[1,0,1,0,0,1,0],[1,0,1,0,0,0,1],[1,0,0,1,1,0,0],[1,0,0,1,0,1,0],[1,0,0,1,0,0,1],[1,0,0,0,1,1,0],[1,0,0,0,1,0,1],[1,0,0,0,0,1,1],[0,1,1,1,0,0,0],[0,1,1,0,1,0,0],[0,1,1,0,0,1,0],[0,1,1,0,0,0,1],[0,1,0,1,1,0,0],[0,1,0,1,0,1,0],[0,1,0,1,0,0,1],[0,1,0,0,1,1,0],[0,1,0,0,1,0,1],[0,1,0,0,0,1,1],[0,0,1,1,1,0,0],[0,0,1,1,0,1,0],[0,0,1,1,0,0,1],[0,0,1,0,1,1,0],[0,0,1,0,1,0,1],[0,0,1,0,0,1,1],[0,0,0,1,1,1,0],[0,0,0,1,1,0,1],[0,0,0,1,0,1,1],[0,0,0,0,1,1,1]]], + "(1, 1, 1, 1, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,0,0,0],[1,1,1,0,1,0,0],[1,1,1,0,0,1,0],[1,1,1,0,0,0,1],[1,1,0,1,1,0,0],[1,1,0,1,0,1,0],[1,1,0,1,0,0,1],[1,1,0,0,1,1,0],[1,1,0,0,1,0,1],[1,1,0,0,0,1,1],[1,0,1,1,1,0,0],[1,0,1,1,0,1,0],[1,0,1,1,0,0,1],[1,0,1,0,1,1,0],[1,0,1,0,1,0,1],[1,0,1,0,0,1,1],[1,0,0,1,1,1,0],[1,0,0,1,1,0,1],[1,0,0,1,0,1,1],[1,0,0,0,1,1,1],[0,1,1,1,1,0,0],[0,1,1,1,0,1,0],[0,1,1,1,0,0,1],[0,1,1,0,1,1,0],[0,1,1,0,1,0,1],[0,1,1,0,0,1,1],[0,1,0,1,1,1,0],[0,1,0,1,1,0,1],[0,1,0,1,0,1,1],[0,1,0,0,1,1,1],[0,0,1,1,1,1,0],[0,0,1,1,1,0,1],[0,0,1,1,0,1,1],[0,0,1,0,1,1,1],[0,0,0,1,1,1,1]]], + "(1, 1, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,0,0],[1,1,1,1,0,1,0],[1,1,1,1,0,0,1],[1,1,1,0,1,1,0],[1,1,1,0,1,0,1],[1,1,1,0,0,1,1],[1,1,0,1,1,1,0],[1,1,0,1,1,0,1],[1,1,0,1,0,1,1],[1,1,0,0,1,1,1],[1,0,1,1,1,1,0],[1,0,1,1,1,0,1],[1,0,1,1,0,1,1],[1,0,1,0,1,1,1],[1,0,0,1,1,1,1],[0,1,1,1,1,1,0],[0,1,1,1,1,0,1],[0,1,1,1,0,1,1],[0,1,1,0,1,1,1],[0,1,0,1,1,1,1],[0,0,1,1,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1],[[1,1,1,1,1,1,0],[1,1,1,1,1,0,1],[1,1,1,1,0,1,1],[1,1,1,0,1,1,1],[1,1,0,1,1,1,1],[1,0,1,1,1,1,1],[0,1,1,1,1,1,1]]], + "(2, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,0,0,0,0,0,0],[1,1,0,0,0,0,0],[1,0,1,0,0,0,0],[1,0,0,1,0,0,0],[1,0,0,0,1,0,0],[1,0,0,0,0,1,0],[1,0,0,0,0,0,1],[0,2,0,0,0,0,0],[0,1,1,0,0,0,0],[0,1,0,1,0,0,0],[0,1,0,0,1,0,0],[0,1,0,0,0,1,0],[0,1,0,0,0,0,1],[0,0,2,0,0,0,0],[0,0,1,1,0,0,0],[0,0,1,0,1,0,0],[0,0,1,0,0,1,0],[0,0,1,0,0,0,1],[0,0,0,2,0,0,0],[0,0,0,1,1,0,0],[0,0,0,1,0,1,0],[0,0,0,1,0,0,1],[0,0,0,0,2,0,0],[0,0,0,0,1,1,0],[0,0,0,0,1,0,1],[0,0,0,0,0,2,0],[0,0,0,0,0,1,1],[0,0,0,0,0,0,2]]], + "(2, 1, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,2,2,2,2,2,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1],[[2,1,0,0,0,0,0],[2,0,1,0,0,0,0],[2,0,0,1,0,0,0],[2,0,0,0,1,0,0],[2,0,0,0,0,1,0],[2,0,0,0,0,0,1],[1,2,0,0,0,0,0],[1,1,1,0,0,0,0],[1,1,0,1,0,0,0],[1,1,0,0,1,0,0],[1,1,0,0,0,1,0],[1,1,0,0,0,0,1],[1,0,2,0,0,0,0],[1,0,1,1,0,0,0],[1,0,1,0,1,0,0],[1,0,1,0,0,1,0],[1,0,1,0,0,0,1],[1,0,0,2,0,0,0],[1,0,0,1,1,0,0],[1,0,0,1,0,1,0],[1,0,0,1,0,0,1],[1,0,0,0,2,0,0],[1,0,0,0,1,1,0],[1,0,0,0,1,0,1],[1,0,0,0,0,2,0],[1,0,0,0,0,1,1],[1,0,0,0,0,0,2],[0,2,1,0,0,0,0],[0,2,0,1,0,0,0],[0,2,0,0,1,0,0],[0,2,0,0,0,1,0],[0,2,0,0,0,0,1],[0,1,2,0,0,0,0],[0,1,1,1,0,0,0],[0,1,1,0,1,0,0],[0,1,1,0,0,1,0],[0,1,1,0,0,0,1],[0,1,0,2,0,0,0],[0,1,0,1,1,0,0],[0,1,0,1,0,1,0],[0,1,0,1,0,0,1],[0,1,0,0,2,0,0],[0,1,0,0,1,1,0],[0,1,0,0,1,0,1],[0,1,0,0,0,2,0],[0,1,0,0,0,1,1],[0,1,0,0,0,0,2],[0,0,2,1,0,0,0],[0,0,2,0,1,0,0],[0,0,2,0,0,1,0],[0,0,2,0,0,0,1],[0,0,1,2,0,0,0],[0,0,1,1,1,0,0],[0,0,1,1,0,1,0],[0,0,1,1,0,0,1],[0,0,1,0,2,0,0],[0,0,1,0,1,1,0],[0,0,1,0,1,0,1],[0,0,1,0,0,2,0],[0,0,1,0,0,1,1],[0,0,1,0,0,0,2],[0,0,0,2,1,0,0],[0,0,0,2,0,1,0],[0,0,0,2,0,0,1],[0,0,0,1,2,0,0],[0,0,0,1,1,1,0],[0,0,0,1,1,0,1],[0,0,0,1,0,2,0],[0,0,0,1,0,1,1],[0,0,0,1,0,0,2],[0,0,0,0,2,1,0],[0,0,0,0,2,0,1],[0,0,0,0,1,2,0],[0,0,0,0,1,1,1],[0,0,0,0,1,0,2],[0,0,0,0,0,2,1],[0,0,0,0,0,1,2]]], + "(2, 1, 1, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,1,3,3,3,1,3,3,1,3,1,1,1,1,1,1,3,3,3,1,3,3,1,3,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,1,3,3,1,3,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,1,3,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1],[[2,1,1,0,0,0,0],[2,1,0,1,0,0,0],[2,1,0,0,1,0,0],[2,1,0,0,0,1,0],[2,1,0,0,0,0,1],[2,0,1,1,0,0,0],[2,0,1,0,1,0,0],[2,0,1,0,0,1,0],[2,0,1,0,0,0,1],[2,0,0,1,1,0,0],[2,0,0,1,0,1,0],[2,0,0,1,0,0,1],[2,0,0,0,1,1,0],[2,0,0,0,1,0,1],[2,0,0,0,0,1,1],[1,2,1,0,0,0,0],[1,2,0,1,0,0,0],[1,2,0,0,1,0,0],[1,2,0,0,0,1,0],[1,2,0,0,0,0,1],[1,1,2,0,0,0,0],[1,1,1,1,0,0,0],[1,1,1,0,1,0,0],[1,1,1,0,0,1,0],[1,1,1,0,0,0,1],[1,1,0,2,0,0,0],[1,1,0,1,1,0,0],[1,1,0,1,0,1,0],[1,1,0,1,0,0,1],[1,1,0,0,2,0,0],[1,1,0,0,1,1,0],[1,1,0,0,1,0,1],[1,1,0,0,0,2,0],[1,1,0,0,0,1,1],[1,1,0,0,0,0,2],[1,0,2,1,0,0,0],[1,0,2,0,1,0,0],[1,0,2,0,0,1,0],[1,0,2,0,0,0,1],[1,0,1,2,0,0,0],[1,0,1,1,1,0,0],[1,0,1,1,0,1,0],[1,0,1,1,0,0,1],[1,0,1,0,2,0,0],[1,0,1,0,1,1,0],[1,0,1,0,1,0,1],[1,0,1,0,0,2,0],[1,0,1,0,0,1,1],[1,0,1,0,0,0,2],[1,0,0,2,1,0,0],[1,0,0,2,0,1,0],[1,0,0,2,0,0,1],[1,0,0,1,2,0,0],[1,0,0,1,1,1,0],[1,0,0,1,1,0,1],[1,0,0,1,0,2,0],[1,0,0,1,0,1,1],[1,0,0,1,0,0,2],[1,0,0,0,2,1,0],[1,0,0,0,2,0,1],[1,0,0,0,1,2,0],[1,0,0,0,1,1,1],[1,0,0,0,1,0,2],[1,0,0,0,0,2,1],[1,0,0,0,0,1,2],[0,2,1,1,0,0,0],[0,2,1,0,1,0,0],[0,2,1,0,0,1,0],[0,2,1,0,0,0,1],[0,2,0,1,1,0,0],[0,2,0,1,0,1,0],[0,2,0,1,0,0,1],[0,2,0,0,1,1,0],[0,2,0,0,1,0,1],[0,2,0,0,0,1,1],[0,1,2,1,0,0,0],[0,1,2,0,1,0,0],[0,1,2,0,0,1,0],[0,1,2,0,0,0,1],[0,1,1,2,0,0,0],[0,1,1,1,1,0,0],[0,1,1,1,0,1,0],[0,1,1,1,0,0,1],[0,1,1,0,2,0,0],[0,1,1,0,1,1,0],[0,1,1,0,1,0,1],[0,1,1,0,0,2,0],[0,1,1,0,0,1,1],[0,1,1,0,0,0,2],[0,1,0,2,1,0,0],[0,1,0,2,0,1,0],[0,1,0,2,0,0,1],[0,1,0,1,2,0,0],[0,1,0,1,1,1,0],[0,1,0,1,1,0,1],[0,1,0,1,0,2,0],[0,1,0,1,0,1,1],[0,1,0,1,0,0,2],[0,1,0,0,2,1,0],[0,1,0,0,2,0,1],[0,1,0,0,1,2,0],[0,1,0,0,1,1,1],[0,1,0,0,1,0,2],[0,1,0,0,0,2,1],[0,1,0,0,0,1,2],[0,0,2,1,1,0,0],[0,0,2,1,0,1,0],[0,0,2,1,0,0,1],[0,0,2,0,1,1,0],[0,0,2,0,1,0,1],[0,0,2,0,0,1,1],[0,0,1,2,1,0,0],[0,0,1,2,0,1,0],[0,0,1,2,0,0,1],[0,0,1,1,2,0,0],[0,0,1,1,1,1,0],[0,0,1,1,1,0,1],[0,0,1,1,0,2,0],[0,0,1,1,0,1,1],[0,0,1,1,0,0,2],[0,0,1,0,2,1,0],[0,0,1,0,2,0,1],[0,0,1,0,1,2,0],[0,0,1,0,1,1,1],[0,0,1,0,1,0,2],[0,0,1,0,0,2,1],[0,0,1,0,0,1,2],[0,0,0,2,1,1,0],[0,0,0,2,1,0,1],[0,0,0,2,0,1,1],[0,0,0,1,2,1,0],[0,0,0,1,2,0,1],[0,0,0,1,1,2,0],[0,0,0,1,1,1,1],[0,0,0,1,1,0,2],[0,0,0,1,0,2,1],[0,0,0,1,0,1,2],[0,0,0,0,2,1,1],[0,0,0,0,1,2,1],[0,0,0,0,1,1,2]]], + "(2, 1, 1, 1, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,4,1,4,4,1,4,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,0,0,0],[2,1,1,0,1,0,0],[2,1,1,0,0,1,0],[2,1,1,0,0,0,1],[2,1,0,1,1,0,0],[2,1,0,1,0,1,0],[2,1,0,1,0,0,1],[2,1,0,0,1,1,0],[2,1,0,0,1,0,1],[2,1,0,0,0,1,1],[2,0,1,1,1,0,0],[2,0,1,1,0,1,0],[2,0,1,1,0,0,1],[2,0,1,0,1,1,0],[2,0,1,0,1,0,1],[2,0,1,0,0,1,1],[2,0,0,1,1,1,0],[2,0,0,1,1,0,1],[2,0,0,1,0,1,1],[2,0,0,0,1,1,1],[1,2,1,1,0,0,0],[1,2,1,0,1,0,0],[1,2,1,0,0,1,0],[1,2,1,0,0,0,1],[1,2,0,1,1,0,0],[1,2,0,1,0,1,0],[1,2,0,1,0,0,1],[1,2,0,0,1,1,0],[1,2,0,0,1,0,1],[1,2,0,0,0,1,1],[1,1,2,1,0,0,0],[1,1,2,0,1,0,0],[1,1,2,0,0,1,0],[1,1,2,0,0,0,1],[1,1,1,2,0,0,0],[1,1,1,1,1,0,0],[1,1,1,1,0,1,0],[1,1,1,1,0,0,1],[1,1,1,0,2,0,0],[1,1,1,0,1,1,0],[1,1,1,0,1,0,1],[1,1,1,0,0,2,0],[1,1,1,0,0,1,1],[1,1,1,0,0,0,2],[1,1,0,2,1,0,0],[1,1,0,2,0,1,0],[1,1,0,2,0,0,1],[1,1,0,1,2,0,0],[1,1,0,1,1,1,0],[1,1,0,1,1,0,1],[1,1,0,1,0,2,0],[1,1,0,1,0,1,1],[1,1,0,1,0,0,2],[1,1,0,0,2,1,0],[1,1,0,0,2,0,1],[1,1,0,0,1,2,0],[1,1,0,0,1,1,1],[1,1,0,0,1,0,2],[1,1,0,0,0,2,1],[1,1,0,0,0,1,2],[1,0,2,1,1,0,0],[1,0,2,1,0,1,0],[1,0,2,1,0,0,1],[1,0,2,0,1,1,0],[1,0,2,0,1,0,1],[1,0,2,0,0,1,1],[1,0,1,2,1,0,0],[1,0,1,2,0,1,0],[1,0,1,2,0,0,1],[1,0,1,1,2,0,0],[1,0,1,1,1,1,0],[1,0,1,1,1,0,1],[1,0,1,1,0,2,0],[1,0,1,1,0,1,1],[1,0,1,1,0,0,2],[1,0,1,0,2,1,0],[1,0,1,0,2,0,1],[1,0,1,0,1,2,0],[1,0,1,0,1,1,1],[1,0,1,0,1,0,2],[1,0,1,0,0,2,1],[1,0,1,0,0,1,2],[1,0,0,2,1,1,0],[1,0,0,2,1,0,1],[1,0,0,2,0,1,1],[1,0,0,1,2,1,0],[1,0,0,1,2,0,1],[1,0,0,1,1,2,0],[1,0,0,1,1,1,1],[1,0,0,1,1,0,2],[1,0,0,1,0,2,1],[1,0,0,1,0,1,2],[1,0,0,0,2,1,1],[1,0,0,0,1,2,1],[1,0,0,0,1,1,2],[0,2,1,1,1,0,0],[0,2,1,1,0,1,0],[0,2,1,1,0,0,1],[0,2,1,0,1,1,0],[0,2,1,0,1,0,1],[0,2,1,0,0,1,1],[0,2,0,1,1,1,0],[0,2,0,1,1,0,1],[0,2,0,1,0,1,1],[0,2,0,0,1,1,1],[0,1,2,1,1,0,0],[0,1,2,1,0,1,0],[0,1,2,1,0,0,1],[0,1,2,0,1,1,0],[0,1,2,0,1,0,1],[0,1,2,0,0,1,1],[0,1,1,2,1,0,0],[0,1,1,2,0,1,0],[0,1,1,2,0,0,1],[0,1,1,1,2,0,0],[0,1,1,1,1,1,0],[0,1,1,1,1,0,1],[0,1,1,1,0,2,0],[0,1,1,1,0,1,1],[0,1,1,1,0,0,2],[0,1,1,0,2,1,0],[0,1,1,0,2,0,1],[0,1,1,0,1,2,0],[0,1,1,0,1,1,1],[0,1,1,0,1,0,2],[0,1,1,0,0,2,1],[0,1,1,0,0,1,2],[0,1,0,2,1,1,0],[0,1,0,2,1,0,1],[0,1,0,2,0,1,1],[0,1,0,1,2,1,0],[0,1,0,1,2,0,1],[0,1,0,1,1,2,0],[0,1,0,1,1,1,1],[0,1,0,1,1,0,2],[0,1,0,1,0,2,1],[0,1,0,1,0,1,2],[0,1,0,0,2,1,1],[0,1,0,0,1,2,1],[0,1,0,0,1,1,2],[0,0,2,1,1,1,0],[0,0,2,1,1,0,1],[0,0,2,1,0,1,1],[0,0,2,0,1,1,1],[0,0,1,2,1,1,0],[0,0,1,2,1,0,1],[0,0,1,2,0,1,1],[0,0,1,1,2,1,0],[0,0,1,1,2,0,1],[0,0,1,1,1,2,0],[0,0,1,1,1,1,1],[0,0,1,1,1,0,2],[0,0,1,1,0,2,1],[0,0,1,1,0,1,2],[0,0,1,0,2,1,1],[0,0,1,0,1,2,1],[0,0,1,0,1,1,2],[0,0,0,2,1,1,1],[0,0,0,1,2,1,1],[0,0,0,1,1,2,1],[0,0,0,1,1,1,2]]], + "(2, 1, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,5,1,1,1,1,5,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,0,0],[2,1,1,1,0,1,0],[2,1,1,1,0,0,1],[2,1,1,0,1,1,0],[2,1,1,0,1,0,1],[2,1,1,0,0,1,1],[2,1,0,1,1,1,0],[2,1,0,1,1,0,1],[2,1,0,1,0,1,1],[2,1,0,0,1,1,1],[2,0,1,1,1,1,0],[2,0,1,1,1,0,1],[2,0,1,1,0,1,1],[2,0,1,0,1,1,1],[2,0,0,1,1,1,1],[1,2,1,1,1,0,0],[1,2,1,1,0,1,0],[1,2,1,1,0,0,1],[1,2,1,0,1,1,0],[1,2,1,0,1,0,1],[1,2,1,0,0,1,1],[1,2,0,1,1,1,0],[1,2,0,1,1,0,1],[1,2,0,1,0,1,1],[1,2,0,0,1,1,1],[1,1,2,1,1,0,0],[1,1,2,1,0,1,0],[1,1,2,1,0,0,1],[1,1,2,0,1,1,0],[1,1,2,0,1,0,1],[1,1,2,0,0,1,1],[1,1,1,2,1,0,0],[1,1,1,2,0,1,0],[1,1,1,2,0,0,1],[1,1,1,1,2,0,0],[1,1,1,1,1,1,0],[1,1,1,1,1,0,1],[1,1,1,1,0,2,0],[1,1,1,1,0,1,1],[1,1,1,1,0,0,2],[1,1,1,0,2,1,0],[1,1,1,0,2,0,1],[1,1,1,0,1,2,0],[1,1,1,0,1,1,1],[1,1,1,0,1,0,2],[1,1,1,0,0,2,1],[1,1,1,0,0,1,2],[1,1,0,2,1,1,0],[1,1,0,2,1,0,1],[1,1,0,2,0,1,1],[1,1,0,1,2,1,0],[1,1,0,1,2,0,1],[1,1,0,1,1,2,0],[1,1,0,1,1,1,1],[1,1,0,1,1,0,2],[1,1,0,1,0,2,1],[1,1,0,1,0,1,2],[1,1,0,0,2,1,1],[1,1,0,0,1,2,1],[1,1,0,0,1,1,2],[1,0,2,1,1,1,0],[1,0,2,1,1,0,1],[1,0,2,1,0,1,1],[1,0,2,0,1,1,1],[1,0,1,2,1,1,0],[1,0,1,2,1,0,1],[1,0,1,2,0,1,1],[1,0,1,1,2,1,0],[1,0,1,1,2,0,1],[1,0,1,1,1,2,0],[1,0,1,1,1,1,1],[1,0,1,1,1,0,2],[1,0,1,1,0,2,1],[1,0,1,1,0,1,2],[1,0,1,0,2,1,1],[1,0,1,0,1,2,1],[1,0,1,0,1,1,2],[1,0,0,2,1,1,1],[1,0,0,1,2,1,1],[1,0,0,1,1,2,1],[1,0,0,1,1,1,2],[0,2,1,1,1,1,0],[0,2,1,1,1,0,1],[0,2,1,1,0,1,1],[0,2,1,0,1,1,1],[0,2,0,1,1,1,1],[0,1,2,1,1,1,0],[0,1,2,1,1,0,1],[0,1,2,1,0,1,1],[0,1,2,0,1,1,1],[0,1,1,2,1,1,0],[0,1,1,2,1,0,1],[0,1,1,2,0,1,1],[0,1,1,1,2,1,0],[0,1,1,1,2,0,1],[0,1,1,1,1,2,0],[0,1,1,1,1,1,1],[0,1,1,1,1,0,2],[0,1,1,1,0,2,1],[0,1,1,1,0,1,2],[0,1,1,0,2,1,1],[0,1,1,0,1,2,1],[0,1,1,0,1,1,2],[0,1,0,2,1,1,1],[0,1,0,1,2,1,1],[0,1,0,1,1,2,1],[0,1,0,1,1,1,2],[0,0,2,1,1,1,1],[0,0,1,2,1,1,1],[0,0,1,1,2,1,1],[0,0,1,1,1,2,1],[0,0,1,1,1,1,2]]], + "(2, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,1,0],[2,1,1,1,1,0,1],[2,1,1,1,0,1,1],[2,1,1,0,1,1,1],[2,1,0,1,1,1,1],[2,0,1,1,1,1,1],[1,2,1,1,1,1,0],[1,2,1,1,1,0,1],[1,2,1,1,0,1,1],[1,2,1,0,1,1,1],[1,2,0,1,1,1,1],[1,1,2,1,1,1,0],[1,1,2,1,1,0,1],[1,1,2,1,0,1,1],[1,1,2,0,1,1,1],[1,1,1,2,1,1,0],[1,1,1,2,1,0,1],[1,1,1,2,0,1,1],[1,1,1,1,2,1,0],[1,1,1,1,2,0,1],[1,1,1,1,1,2,0],[1,1,1,1,1,1,1],[1,1,1,1,1,0,2],[1,1,1,1,0,2,1],[1,1,1,1,0,1,2],[1,1,1,0,2,1,1],[1,1,1,0,1,2,1],[1,1,1,0,1,1,2],[1,1,0,2,1,1,1],[1,1,0,1,2,1,1],[1,1,0,1,1,2,1],[1,1,0,1,1,1,2],[1,0,2,1,1,1,1],[1,0,1,2,1,1,1],[1,0,1,1,2,1,1],[1,0,1,1,1,2,1],[1,0,1,1,1,1,2],[0,2,1,1,1,1,1],[0,1,2,1,1,1,1],[0,1,1,2,1,1,1],[0,1,1,1,2,1,1],[0,1,1,1,1,2,1],[0,1,1,1,1,1,2]]], + "(2, 2, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1],[[2,2,0,0,0,0,0],[2,1,1,0,0,0,0],[2,1,0,1,0,0,0],[2,1,0,0,1,0,0],[2,1,0,0,0,1,0],[2,1,0,0,0,0,1],[2,0,2,0,0,0,0],[2,0,1,1,0,0,0],[2,0,1,0,1,0,0],[2,0,1,0,0,1,0],[2,0,1,0,0,0,1],[2,0,0,2,0,0,0],[2,0,0,1,1,0,0],[2,0,0,1,0,1,0],[2,0,0,1,0,0,1],[2,0,0,0,2,0,0],[2,0,0,0,1,1,0],[2,0,0,0,1,0,1],[2,0,0,0,0,2,0],[2,0,0,0,0,1,1],[2,0,0,0,0,0,2],[1,2,1,0,0,0,0],[1,2,0,1,0,0,0],[1,2,0,0,1,0,0],[1,2,0,0,0,1,0],[1,2,0,0,0,0,1],[1,1,2,0,0,0,0],[1,1,1,1,0,0,0],[1,1,1,0,1,0,0],[1,1,1,0,0,1,0],[1,1,1,0,0,0,1],[1,1,0,2,0,0,0],[1,1,0,1,1,0,0],[1,1,0,1,0,1,0],[1,1,0,1,0,0,1],[1,1,0,0,2,0,0],[1,1,0,0,1,1,0],[1,1,0,0,1,0,1],[1,1,0,0,0,2,0],[1,1,0,0,0,1,1],[1,1,0,0,0,0,2],[1,0,2,1,0,0,0],[1,0,2,0,1,0,0],[1,0,2,0,0,1,0],[1,0,2,0,0,0,1],[1,0,1,2,0,0,0],[1,0,1,1,1,0,0],[1,0,1,1,0,1,0],[1,0,1,1,0,0,1],[1,0,1,0,2,0,0],[1,0,1,0,1,1,0],[1,0,1,0,1,0,1],[1,0,1,0,0,2,0],[1,0,1,0,0,1,1],[1,0,1,0,0,0,2],[1,0,0,2,1,0,0],[1,0,0,2,0,1,0],[1,0,0,2,0,0,1],[1,0,0,1,2,0,0],[1,0,0,1,1,1,0],[1,0,0,1,1,0,1],[1,0,0,1,0,2,0],[1,0,0,1,0,1,1],[1,0,0,1,0,0,2],[1,0,0,0,2,1,0],[1,0,0,0,2,0,1],[1,0,0,0,1,2,0],[1,0,0,0,1,1,1],[1,0,0,0,1,0,2],[1,0,0,0,0,2,1],[1,0,0,0,0,1,2],[0,2,2,0,0,0,0],[0,2,1,1,0,0,0],[0,2,1,0,1,0,0],[0,2,1,0,0,1,0],[0,2,1,0,0,0,1],[0,2,0,2,0,0,0],[0,2,0,1,1,0,0],[0,2,0,1,0,1,0],[0,2,0,1,0,0,1],[0,2,0,0,2,0,0],[0,2,0,0,1,1,0],[0,2,0,0,1,0,1],[0,2,0,0,0,2,0],[0,2,0,0,0,1,1],[0,2,0,0,0,0,2],[0,1,2,1,0,0,0],[0,1,2,0,1,0,0],[0,1,2,0,0,1,0],[0,1,2,0,0,0,1],[0,1,1,2,0,0,0],[0,1,1,1,1,0,0],[0,1,1,1,0,1,0],[0,1,1,1,0,0,1],[0,1,1,0,2,0,0],[0,1,1,0,1,1,0],[0,1,1,0,1,0,1],[0,1,1,0,0,2,0],[0,1,1,0,0,1,1],[0,1,1,0,0,0,2],[0,1,0,2,1,0,0],[0,1,0,2,0,1,0],[0,1,0,2,0,0,1],[0,1,0,1,2,0,0],[0,1,0,1,1,1,0],[0,1,0,1,1,0,1],[0,1,0,1,0,2,0],[0,1,0,1,0,1,1],[0,1,0,1,0,0,2],[0,1,0,0,2,1,0],[0,1,0,0,2,0,1],[0,1,0,0,1,2,0],[0,1,0,0,1,1,1],[0,1,0,0,1,0,2],[0,1,0,0,0,2,1],[0,1,0,0,0,1,2],[0,0,2,2,0,0,0],[0,0,2,1,1,0,0],[0,0,2,1,0,1,0],[0,0,2,1,0,0,1],[0,0,2,0,2,0,0],[0,0,2,0,1,1,0],[0,0,2,0,1,0,1],[0,0,2,0,0,2,0],[0,0,2,0,0,1,1],[0,0,2,0,0,0,2],[0,0,1,2,1,0,0],[0,0,1,2,0,1,0],[0,0,1,2,0,0,1],[0,0,1,1,2,0,0],[0,0,1,1,1,1,0],[0,0,1,1,1,0,1],[0,0,1,1,0,2,0],[0,0,1,1,0,1,1],[0,0,1,1,0,0,2],[0,0,1,0,2,1,0],[0,0,1,0,2,0,1],[0,0,1,0,1,2,0],[0,0,1,0,1,1,1],[0,0,1,0,1,0,2],[0,0,1,0,0,2,1],[0,0,1,0,0,1,2],[0,0,0,2,2,0,0],[0,0,0,2,1,1,0],[0,0,0,2,1,0,1],[0,0,0,2,0,2,0],[0,0,0,2,0,1,1],[0,0,0,2,0,0,2],[0,0,0,1,2,1,0],[0,0,0,1,2,0,1],[0,0,0,1,1,2,0],[0,0,0,1,1,1,1],[0,0,0,1,1,0,2],[0,0,0,1,0,2,1],[0,0,0,1,0,1,2],[0,0,0,0,2,2,0],[0,0,0,0,2,1,1],[0,0,0,0,2,0,2],[0,0,0,0,1,2,1],[0,0,0,0,1,1,2],[0,0,0,0,0,2,2]]], + "(2, 2, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,4,4,1,4,1,1,1,1,4,1,1,1,1,4,4,1,4,1,4,4,4,14,4,4,4,1,4,1,4,4,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,1,1,1,0,0],[2,2,1,1,0,1,0],[2,2,1,1,0,0,1],[2,2,1,0,1,1,0],[2,2,1,0,1,0,1],[2,2,1,0,0,1,1],[2,2,0,1,1,1,0],[2,2,0,1,1,0,1],[2,2,0,1,0,1,1],[2,2,0,0,1,1,1],[2,1,2,1,1,0,0],[2,1,2,1,0,1,0],[2,1,2,1,0,0,1],[2,1,2,0,1,1,0],[2,1,2,0,1,0,1],[2,1,2,0,0,1,1],[2,1,1,2,1,0,0],[2,1,1,2,0,1,0],[2,1,1,2,0,0,1],[2,1,1,1,2,0,0],[2,1,1,1,1,1,0],[2,1,1,1,1,0,1],[2,1,1,1,0,2,0],[2,1,1,1,0,1,1],[2,1,1,1,0,0,2],[2,1,1,0,2,1,0],[2,1,1,0,2,0,1],[2,1,1,0,1,2,0],[2,1,1,0,1,1,1],[2,1,1,0,1,0,2],[2,1,1,0,0,2,1],[2,1,1,0,0,1,2],[2,1,0,2,1,1,0],[2,1,0,2,1,0,1],[2,1,0,2,0,1,1],[2,1,0,1,2,1,0],[2,1,0,1,2,0,1],[2,1,0,1,1,2,0],[2,1,0,1,1,1,1],[2,1,0,1,1,0,2],[2,1,0,1,0,2,1],[2,1,0,1,0,1,2],[2,1,0,0,2,1,1],[2,1,0,0,1,2,1],[2,1,0,0,1,1,2],[2,0,2,1,1,1,0],[2,0,2,1,1,0,1],[2,0,2,1,0,1,1],[2,0,2,0,1,1,1],[2,0,1,2,1,1,0],[2,0,1,2,1,0,1],[2,0,1,2,0,1,1],[2,0,1,1,2,1,0],[2,0,1,1,2,0,1],[2,0,1,1,1,2,0],[2,0,1,1,1,1,1],[2,0,1,1,1,0,2],[2,0,1,1,0,2,1],[2,0,1,1,0,1,2],[2,0,1,0,2,1,1],[2,0,1,0,1,2,1],[2,0,1,0,1,1,2],[2,0,0,2,1,1,1],[2,0,0,1,2,1,1],[2,0,0,1,1,2,1],[2,0,0,1,1,1,2],[1,2,2,1,1,0,0],[1,2,2,1,0,1,0],[1,2,2,1,0,0,1],[1,2,2,0,1,1,0],[1,2,2,0,1,0,1],[1,2,2,0,0,1,1],[1,2,1,2,1,0,0],[1,2,1,2,0,1,0],[1,2,1,2,0,0,1],[1,2,1,1,2,0,0],[1,2,1,1,1,1,0],[1,2,1,1,1,0,1],[1,2,1,1,0,2,0],[1,2,1,1,0,1,1],[1,2,1,1,0,0,2],[1,2,1,0,2,1,0],[1,2,1,0,2,0,1],[1,2,1,0,1,2,0],[1,2,1,0,1,1,1],[1,2,1,0,1,0,2],[1,2,1,0,0,2,1],[1,2,1,0,0,1,2],[1,2,0,2,1,1,0],[1,2,0,2,1,0,1],[1,2,0,2,0,1,1],[1,2,0,1,2,1,0],[1,2,0,1,2,0,1],[1,2,0,1,1,2,0],[1,2,0,1,1,1,1],[1,2,0,1,1,0,2],[1,2,0,1,0,2,1],[1,2,0,1,0,1,2],[1,2,0,0,2,1,1],[1,2,0,0,1,2,1],[1,2,0,0,1,1,2],[1,1,2,2,1,0,0],[1,1,2,2,0,1,0],[1,1,2,2,0,0,1],[1,1,2,1,2,0,0],[1,1,2,1,1,1,0],[1,1,2,1,1,0,1],[1,1,2,1,0,2,0],[1,1,2,1,0,1,1],[1,1,2,1,0,0,2],[1,1,2,0,2,1,0],[1,1,2,0,2,0,1],[1,1,2,0,1,2,0],[1,1,2,0,1,1,1],[1,1,2,0,1,0,2],[1,1,2,0,0,2,1],[1,1,2,0,0,1,2],[1,1,1,2,2,0,0],[1,1,1,2,1,1,0],[1,1,1,2,1,0,1],[1,1,1,2,0,2,0],[1,1,1,2,0,1,1],[1,1,1,2,0,0,2],[1,1,1,1,2,1,0],[1,1,1,1,2,0,1],[1,1,1,1,1,2,0],[1,1,1,1,1,1,1],[1,1,1,1,1,0,2],[1,1,1,1,0,2,1],[1,1,1,1,0,1,2],[1,1,1,0,2,2,0],[1,1,1,0,2,1,1],[1,1,1,0,2,0,2],[1,1,1,0,1,2,1],[1,1,1,0,1,1,2],[1,1,1,0,0,2,2],[1,1,0,2,2,1,0],[1,1,0,2,2,0,1],[1,1,0,2,1,2,0],[1,1,0,2,1,1,1],[1,1,0,2,1,0,2],[1,1,0,2,0,2,1],[1,1,0,2,0,1,2],[1,1,0,1,2,2,0],[1,1,0,1,2,1,1],[1,1,0,1,2,0,2],[1,1,0,1,1,2,1],[1,1,0,1,1,1,2],[1,1,0,1,0,2,2],[1,1,0,0,2,2,1],[1,1,0,0,2,1,2],[1,1,0,0,1,2,2],[1,0,2,2,1,1,0],[1,0,2,2,1,0,1],[1,0,2,2,0,1,1],[1,0,2,1,2,1,0],[1,0,2,1,2,0,1],[1,0,2,1,1,2,0],[1,0,2,1,1,1,1],[1,0,2,1,1,0,2],[1,0,2,1,0,2,1],[1,0,2,1,0,1,2],[1,0,2,0,2,1,1],[1,0,2,0,1,2,1],[1,0,2,0,1,1,2],[1,0,1,2,2,1,0],[1,0,1,2,2,0,1],[1,0,1,2,1,2,0],[1,0,1,2,1,1,1],[1,0,1,2,1,0,2],[1,0,1,2,0,2,1],[1,0,1,2,0,1,2],[1,0,1,1,2,2,0],[1,0,1,1,2,1,1],[1,0,1,1,2,0,2],[1,0,1,1,1,2,1],[1,0,1,1,1,1,2],[1,0,1,1,0,2,2],[1,0,1,0,2,2,1],[1,0,1,0,2,1,2],[1,0,1,0,1,2,2],[1,0,0,2,2,1,1],[1,0,0,2,1,2,1],[1,0,0,2,1,1,2],[1,0,0,1,2,2,1],[1,0,0,1,2,1,2],[1,0,0,1,1,2,2],[0,2,2,1,1,1,0],[0,2,2,1,1,0,1],[0,2,2,1,0,1,1],[0,2,2,0,1,1,1],[0,2,1,2,1,1,0],[0,2,1,2,1,0,1],[0,2,1,2,0,1,1],[0,2,1,1,2,1,0],[0,2,1,1,2,0,1],[0,2,1,1,1,2,0],[0,2,1,1,1,1,1],[0,2,1,1,1,0,2],[0,2,1,1,0,2,1],[0,2,1,1,0,1,2],[0,2,1,0,2,1,1],[0,2,1,0,1,2,1],[0,2,1,0,1,1,2],[0,2,0,2,1,1,1],[0,2,0,1,2,1,1],[0,2,0,1,1,2,1],[0,2,0,1,1,1,2],[0,1,2,2,1,1,0],[0,1,2,2,1,0,1],[0,1,2,2,0,1,1],[0,1,2,1,2,1,0],[0,1,2,1,2,0,1],[0,1,2,1,1,2,0],[0,1,2,1,1,1,1],[0,1,2,1,1,0,2],[0,1,2,1,0,2,1],[0,1,2,1,0,1,2],[0,1,2,0,2,1,1],[0,1,2,0,1,2,1],[0,1,2,0,1,1,2],[0,1,1,2,2,1,0],[0,1,1,2,2,0,1],[0,1,1,2,1,2,0],[0,1,1,2,1,1,1],[0,1,1,2,1,0,2],[0,1,1,2,0,2,1],[0,1,1,2,0,1,2],[0,1,1,1,2,2,0],[0,1,1,1,2,1,1],[0,1,1,1,2,0,2],[0,1,1,1,1,2,1],[0,1,1,1,1,1,2],[0,1,1,1,0,2,2],[0,1,1,0,2,2,1],[0,1,1,0,2,1,2],[0,1,1,0,1,2,2],[0,1,0,2,2,1,1],[0,1,0,2,1,2,1],[0,1,0,2,1,1,2],[0,1,0,1,2,2,1],[0,1,0,1,2,1,2],[0,1,0,1,1,2,2],[0,0,2,2,1,1,1],[0,0,2,1,2,1,1],[0,0,2,1,1,2,1],[0,0,2,1,1,1,2],[0,0,1,2,2,1,1],[0,0,1,2,1,2,1],[0,0,1,2,1,1,2],[0,0,1,1,2,2,1],[0,0,1,1,2,1,2],[0,0,1,1,1,2,2]]], + "(2, 2, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,5,1,1,1,1,5,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,1,1,1,1,0],[2,2,1,1,1,0,1],[2,2,1,1,0,1,1],[2,2,1,0,1,1,1],[2,2,0,1,1,1,1],[2,1,2,1,1,1,0],[2,1,2,1,1,0,1],[2,1,2,1,0,1,1],[2,1,2,0,1,1,1],[2,1,1,2,1,1,0],[2,1,1,2,1,0,1],[2,1,1,2,0,1,1],[2,1,1,1,2,1,0],[2,1,1,1,2,0,1],[2,1,1,1,1,2,0],[2,1,1,1,1,1,1],[2,1,1,1,1,0,2],[2,1,1,1,0,2,1],[2,1,1,1,0,1,2],[2,1,1,0,2,1,1],[2,1,1,0,1,2,1],[2,1,1,0,1,1,2],[2,1,0,2,1,1,1],[2,1,0,1,2,1,1],[2,1,0,1,1,2,1],[2,1,0,1,1,1,2],[2,0,2,1,1,1,1],[2,0,1,2,1,1,1],[2,0,1,1,2,1,1],[2,0,1,1,1,2,1],[2,0,1,1,1,1,2],[1,2,2,1,1,1,0],[1,2,2,1,1,0,1],[1,2,2,1,0,1,1],[1,2,2,0,1,1,1],[1,2,1,2,1,1,0],[1,2,1,2,1,0,1],[1,2,1,2,0,1,1],[1,2,1,1,2,1,0],[1,2,1,1,2,0,1],[1,2,1,1,1,2,0],[1,2,1,1,1,1,1],[1,2,1,1,1,0,2],[1,2,1,1,0,2,1],[1,2,1,1,0,1,2],[1,2,1,0,2,1,1],[1,2,1,0,1,2,1],[1,2,1,0,1,1,2],[1,2,0,2,1,1,1],[1,2,0,1,2,1,1],[1,2,0,1,1,2,1],[1,2,0,1,1,1,2],[1,1,2,2,1,1,0],[1,1,2,2,1,0,1],[1,1,2,2,0,1,1],[1,1,2,1,2,1,0],[1,1,2,1,2,0,1],[1,1,2,1,1,2,0],[1,1,2,1,1,1,1],[1,1,2,1,1,0,2],[1,1,2,1,0,2,1],[1,1,2,1,0,1,2],[1,1,2,0,2,1,1],[1,1,2,0,1,2,1],[1,1,2,0,1,1,2],[1,1,1,2,2,1,0],[1,1,1,2,2,0,1],[1,1,1,2,1,2,0],[1,1,1,2,1,1,1],[1,1,1,2,1,0,2],[1,1,1,2,0,2,1],[1,1,1,2,0,1,2],[1,1,1,1,2,2,0],[1,1,1,1,2,1,1],[1,1,1,1,2,0,2],[1,1,1,1,1,2,1],[1,1,1,1,1,1,2],[1,1,1,1,0,2,2],[1,1,1,0,2,2,1],[1,1,1,0,2,1,2],[1,1,1,0,1,2,2],[1,1,0,2,2,1,1],[1,1,0,2,1,2,1],[1,1,0,2,1,1,2],[1,1,0,1,2,2,1],[1,1,0,1,2,1,2],[1,1,0,1,1,2,2],[1,0,2,2,1,1,1],[1,0,2,1,2,1,1],[1,0,2,1,1,2,1],[1,0,2,1,1,1,2],[1,0,1,2,2,1,1],[1,0,1,2,1,2,1],[1,0,1,2,1,1,2],[1,0,1,1,2,2,1],[1,0,1,1,2,1,2],[1,0,1,1,1,2,2],[0,2,2,1,1,1,1],[0,2,1,2,1,1,1],[0,2,1,1,2,1,1],[0,2,1,1,1,2,1],[0,2,1,1,1,1,2],[0,1,2,2,1,1,1],[0,1,2,1,2,1,1],[0,1,2,1,1,2,1],[0,1,2,1,1,1,2],[0,1,1,2,2,1,1],[0,1,1,2,1,2,1],[0,1,1,2,1,1,2],[0,1,1,1,2,2,1],[0,1,1,1,2,1,2],[0,1,1,1,1,2,2]]], + "(2, 2, 2, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,4,1,4,4,1,1,1,1,1,4,1,4,4,1,4,4,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,1,1,1,0],[2,2,2,1,1,0,1],[2,2,2,1,0,1,1],[2,2,2,0,1,1,1],[2,2,1,2,1,1,0],[2,2,1,2,1,0,1],[2,2,1,2,0,1,1],[2,2,1,1,2,1,0],[2,2,1,1,2,0,1],[2,2,1,1,1,2,0],[2,2,1,1,1,1,1],[2,2,1,1,1,0,2],[2,2,1,1,0,2,1],[2,2,1,1,0,1,2],[2,2,1,0,2,1,1],[2,2,1,0,1,2,1],[2,2,1,0,1,1,2],[2,2,0,2,1,1,1],[2,2,0,1,2,1,1],[2,2,0,1,1,2,1],[2,2,0,1,1,1,2],[2,1,2,2,1,1,0],[2,1,2,2,1,0,1],[2,1,2,2,0,1,1],[2,1,2,1,2,1,0],[2,1,2,1,2,0,1],[2,1,2,1,1,2,0],[2,1,2,1,1,1,1],[2,1,2,1,1,0,2],[2,1,2,1,0,2,1],[2,1,2,1,0,1,2],[2,1,2,0,2,1,1],[2,1,2,0,1,2,1],[2,1,2,0,1,1,2],[2,1,1,2,2,1,0],[2,1,1,2,2,0,1],[2,1,1,2,1,2,0],[2,1,1,2,1,1,1],[2,1,1,2,1,0,2],[2,1,1,2,0,2,1],[2,1,1,2,0,1,2],[2,1,1,1,2,2,0],[2,1,1,1,2,1,1],[2,1,1,1,2,0,2],[2,1,1,1,1,2,1],[2,1,1,1,1,1,2],[2,1,1,1,0,2,2],[2,1,1,0,2,2,1],[2,1,1,0,2,1,2],[2,1,1,0,1,2,2],[2,1,0,2,2,1,1],[2,1,0,2,1,2,1],[2,1,0,2,1,1,2],[2,1,0,1,2,2,1],[2,1,0,1,2,1,2],[2,1,0,1,1,2,2],[2,0,2,2,1,1,1],[2,0,2,1,2,1,1],[2,0,2,1,1,2,1],[2,0,2,1,1,1,2],[2,0,1,2,2,1,1],[2,0,1,2,1,2,1],[2,0,1,2,1,1,2],[2,0,1,1,2,2,1],[2,0,1,1,2,1,2],[2,0,1,1,1,2,2],[1,2,2,2,1,1,0],[1,2,2,2,1,0,1],[1,2,2,2,0,1,1],[1,2,2,1,2,1,0],[1,2,2,1,2,0,1],[1,2,2,1,1,2,0],[1,2,2,1,1,1,1],[1,2,2,1,1,0,2],[1,2,2,1,0,2,1],[1,2,2,1,0,1,2],[1,2,2,0,2,1,1],[1,2,2,0,1,2,1],[1,2,2,0,1,1,2],[1,2,1,2,2,1,0],[1,2,1,2,2,0,1],[1,2,1,2,1,2,0],[1,2,1,2,1,1,1],[1,2,1,2,1,0,2],[1,2,1,2,0,2,1],[1,2,1,2,0,1,2],[1,2,1,1,2,2,0],[1,2,1,1,2,1,1],[1,2,1,1,2,0,2],[1,2,1,1,1,2,1],[1,2,1,1,1,1,2],[1,2,1,1,0,2,2],[1,2,1,0,2,2,1],[1,2,1,0,2,1,2],[1,2,1,0,1,2,2],[1,2,0,2,2,1,1],[1,2,0,2,1,2,1],[1,2,0,2,1,1,2],[1,2,0,1,2,2,1],[1,2,0,1,2,1,2],[1,2,0,1,1,2,2],[1,1,2,2,2,1,0],[1,1,2,2,2,0,1],[1,1,2,2,1,2,0],[1,1,2,2,1,1,1],[1,1,2,2,1,0,2],[1,1,2,2,0,2,1],[1,1,2,2,0,1,2],[1,1,2,1,2,2,0],[1,1,2,1,2,1,1],[1,1,2,1,2,0,2],[1,1,2,1,1,2,1],[1,1,2,1,1,1,2],[1,1,2,1,0,2,2],[1,1,2,0,2,2,1],[1,1,2,0,2,1,2],[1,1,2,0,1,2,2],[1,1,1,2,2,2,0],[1,1,1,2,2,1,1],[1,1,1,2,2,0,2],[1,1,1,2,1,2,1],[1,1,1,2,1,1,2],[1,1,1,2,0,2,2],[1,1,1,1,2,2,1],[1,1,1,1,2,1,2],[1,1,1,1,1,2,2],[1,1,1,0,2,2,2],[1,1,0,2,2,2,1],[1,1,0,2,2,1,2],[1,1,0,2,1,2,2],[1,1,0,1,2,2,2],[1,0,2,2,2,1,1],[1,0,2,2,1,2,1],[1,0,2,2,1,1,2],[1,0,2,1,2,2,1],[1,0,2,1,2,1,2],[1,0,2,1,1,2,2],[1,0,1,2,2,2,1],[1,0,1,2,2,1,2],[1,0,1,2,1,2,2],[1,0,1,1,2,2,2],[0,2,2,2,1,1,1],[0,2,2,1,2,1,1],[0,2,2,1,1,2,1],[0,2,2,1,1,1,2],[0,2,1,2,2,1,1],[0,2,1,2,1,2,1],[0,2,1,2,1,1,2],[0,2,1,1,2,2,1],[0,2,1,1,2,1,2],[0,2,1,1,1,2,2],[0,1,2,2,2,1,1],[0,1,2,2,1,2,1],[0,1,2,2,1,1,2],[0,1,2,1,2,2,1],[0,1,2,1,2,1,2],[0,1,2,1,1,2,2],[0,1,1,2,2,2,1],[0,1,1,2,2,1,2],[0,1,1,2,1,2,2],[0,1,1,1,2,2,2]]], + "(2, 2, 2, 2, 1, 1, 0)": [[1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,3,1,3,3,1,3,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,3,1,3,3,1,1,1,1,1,3,1,3,3,1,3,3,3,1,1,1,1,1,1,3,1,3,3,1,3,3,3,1,3,3,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,1,1,0],[2,2,2,2,1,0,1],[2,2,2,2,0,1,1],[2,2,2,1,2,1,0],[2,2,2,1,2,0,1],[2,2,2,1,1,2,0],[2,2,2,1,1,1,1],[2,2,2,1,1,0,2],[2,2,2,1,0,2,1],[2,2,2,1,0,1,2],[2,2,2,0,2,1,1],[2,2,2,0,1,2,1],[2,2,2,0,1,1,2],[2,2,1,2,2,1,0],[2,2,1,2,2,0,1],[2,2,1,2,1,2,0],[2,2,1,2,1,1,1],[2,2,1,2,1,0,2],[2,2,1,2,0,2,1],[2,2,1,2,0,1,2],[2,2,1,1,2,2,0],[2,2,1,1,2,1,1],[2,2,1,1,2,0,2],[2,2,1,1,1,2,1],[2,2,1,1,1,1,2],[2,2,1,1,0,2,2],[2,2,1,0,2,2,1],[2,2,1,0,2,1,2],[2,2,1,0,1,2,2],[2,2,0,2,2,1,1],[2,2,0,2,1,2,1],[2,2,0,2,1,1,2],[2,2,0,1,2,2,1],[2,2,0,1,2,1,2],[2,2,0,1,1,2,2],[2,1,2,2,2,1,0],[2,1,2,2,2,0,1],[2,1,2,2,1,2,0],[2,1,2,2,1,1,1],[2,1,2,2,1,0,2],[2,1,2,2,0,2,1],[2,1,2,2,0,1,2],[2,1,2,1,2,2,0],[2,1,2,1,2,1,1],[2,1,2,1,2,0,2],[2,1,2,1,1,2,1],[2,1,2,1,1,1,2],[2,1,2,1,0,2,2],[2,1,2,0,2,2,1],[2,1,2,0,2,1,2],[2,1,2,0,1,2,2],[2,1,1,2,2,2,0],[2,1,1,2,2,1,1],[2,1,1,2,2,0,2],[2,1,1,2,1,2,1],[2,1,1,2,1,1,2],[2,1,1,2,0,2,2],[2,1,1,1,2,2,1],[2,1,1,1,2,1,2],[2,1,1,1,1,2,2],[2,1,1,0,2,2,2],[2,1,0,2,2,2,1],[2,1,0,2,2,1,2],[2,1,0,2,1,2,2],[2,1,0,1,2,2,2],[2,0,2,2,2,1,1],[2,0,2,2,1,2,1],[2,0,2,2,1,1,2],[2,0,2,1,2,2,1],[2,0,2,1,2,1,2],[2,0,2,1,1,2,2],[2,0,1,2,2,2,1],[2,0,1,2,2,1,2],[2,0,1,2,1,2,2],[2,0,1,1,2,2,2],[1,2,2,2,2,1,0],[1,2,2,2,2,0,1],[1,2,2,2,1,2,0],[1,2,2,2,1,1,1],[1,2,2,2,1,0,2],[1,2,2,2,0,2,1],[1,2,2,2,0,1,2],[1,2,2,1,2,2,0],[1,2,2,1,2,1,1],[1,2,2,1,2,0,2],[1,2,2,1,1,2,1],[1,2,2,1,1,1,2],[1,2,2,1,0,2,2],[1,2,2,0,2,2,1],[1,2,2,0,2,1,2],[1,2,2,0,1,2,2],[1,2,1,2,2,2,0],[1,2,1,2,2,1,1],[1,2,1,2,2,0,2],[1,2,1,2,1,2,1],[1,2,1,2,1,1,2],[1,2,1,2,0,2,2],[1,2,1,1,2,2,1],[1,2,1,1,2,1,2],[1,2,1,1,1,2,2],[1,2,1,0,2,2,2],[1,2,0,2,2,2,1],[1,2,0,2,2,1,2],[1,2,0,2,1,2,2],[1,2,0,1,2,2,2],[1,1,2,2,2,2,0],[1,1,2,2,2,1,1],[1,1,2,2,2,0,2],[1,1,2,2,1,2,1],[1,1,2,2,1,1,2],[1,1,2,2,0,2,2],[1,1,2,1,2,2,1],[1,1,2,1,2,1,2],[1,1,2,1,1,2,2],[1,1,2,0,2,2,2],[1,1,1,2,2,2,1],[1,1,1,2,2,1,2],[1,1,1,2,1,2,2],[1,1,1,1,2,2,2],[1,1,0,2,2,2,2],[1,0,2,2,2,2,1],[1,0,2,2,2,1,2],[1,0,2,2,1,2,2],[1,0,2,1,2,2,2],[1,0,1,2,2,2,2],[0,2,2,2,2,1,1],[0,2,2,2,1,2,1],[0,2,2,2,1,1,2],[0,2,2,1,2,2,1],[0,2,2,1,2,1,2],[0,2,2,1,1,2,2],[0,2,1,2,2,2,1],[0,2,1,2,2,1,2],[0,2,1,2,1,2,2],[0,2,1,1,2,2,2],[0,1,2,2,2,2,1],[0,1,2,2,2,1,2],[0,1,2,2,1,2,2],[0,1,2,1,2,2,2],[0,1,1,2,2,2,2]]], + "(2, 2, 2, 2, 2, 0, 0)": [[1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,2,0,0],[2,2,2,2,1,1,0],[2,2,2,2,1,0,1],[2,2,2,2,0,2,0],[2,2,2,2,0,1,1],[2,2,2,2,0,0,2],[2,2,2,1,2,1,0],[2,2,2,1,2,0,1],[2,2,2,1,1,2,0],[2,2,2,1,1,1,1],[2,2,2,1,1,0,2],[2,2,2,1,0,2,1],[2,2,2,1,0,1,2],[2,2,2,0,2,2,0],[2,2,2,0,2,1,1],[2,2,2,0,2,0,2],[2,2,2,0,1,2,1],[2,2,2,0,1,1,2],[2,2,2,0,0,2,2],[2,2,1,2,2,1,0],[2,2,1,2,2,0,1],[2,2,1,2,1,2,0],[2,2,1,2,1,1,1],[2,2,1,2,1,0,2],[2,2,1,2,0,2,1],[2,2,1,2,0,1,2],[2,2,1,1,2,2,0],[2,2,1,1,2,1,1],[2,2,1,1,2,0,2],[2,2,1,1,1,2,1],[2,2,1,1,1,1,2],[2,2,1,1,0,2,2],[2,2,1,0,2,2,1],[2,2,1,0,2,1,2],[2,2,1,0,1,2,2],[2,2,0,2,2,2,0],[2,2,0,2,2,1,1],[2,2,0,2,2,0,2],[2,2,0,2,1,2,1],[2,2,0,2,1,1,2],[2,2,0,2,0,2,2],[2,2,0,1,2,2,1],[2,2,0,1,2,1,2],[2,2,0,1,1,2,2],[2,2,0,0,2,2,2],[2,1,2,2,2,1,0],[2,1,2,2,2,0,1],[2,1,2,2,1,2,0],[2,1,2,2,1,1,1],[2,1,2,2,1,0,2],[2,1,2,2,0,2,1],[2,1,2,2,0,1,2],[2,1,2,1,2,2,0],[2,1,2,1,2,1,1],[2,1,2,1,2,0,2],[2,1,2,1,1,2,1],[2,1,2,1,1,1,2],[2,1,2,1,0,2,2],[2,1,2,0,2,2,1],[2,1,2,0,2,1,2],[2,1,2,0,1,2,2],[2,1,1,2,2,2,0],[2,1,1,2,2,1,1],[2,1,1,2,2,0,2],[2,1,1,2,1,2,1],[2,1,1,2,1,1,2],[2,1,1,2,0,2,2],[2,1,1,1,2,2,1],[2,1,1,1,2,1,2],[2,1,1,1,1,2,2],[2,1,1,0,2,2,2],[2,1,0,2,2,2,1],[2,1,0,2,2,1,2],[2,1,0,2,1,2,2],[2,1,0,1,2,2,2],[2,0,2,2,2,2,0],[2,0,2,2,2,1,1],[2,0,2,2,2,0,2],[2,0,2,2,1,2,1],[2,0,2,2,1,1,2],[2,0,2,2,0,2,2],[2,0,2,1,2,2,1],[2,0,2,1,2,1,2],[2,0,2,1,1,2,2],[2,0,2,0,2,2,2],[2,0,1,2,2,2,1],[2,0,1,2,2,1,2],[2,0,1,2,1,2,2],[2,0,1,1,2,2,2],[2,0,0,2,2,2,2],[1,2,2,2,2,1,0],[1,2,2,2,2,0,1],[1,2,2,2,1,2,0],[1,2,2,2,1,1,1],[1,2,2,2,1,0,2],[1,2,2,2,0,2,1],[1,2,2,2,0,1,2],[1,2,2,1,2,2,0],[1,2,2,1,2,1,1],[1,2,2,1,2,0,2],[1,2,2,1,1,2,1],[1,2,2,1,1,1,2],[1,2,2,1,0,2,2],[1,2,2,0,2,2,1],[1,2,2,0,2,1,2],[1,2,2,0,1,2,2],[1,2,1,2,2,2,0],[1,2,1,2,2,1,1],[1,2,1,2,2,0,2],[1,2,1,2,1,2,1],[1,2,1,2,1,1,2],[1,2,1,2,0,2,2],[1,2,1,1,2,2,1],[1,2,1,1,2,1,2],[1,2,1,1,1,2,2],[1,2,1,0,2,2,2],[1,2,0,2,2,2,1],[1,2,0,2,2,1,2],[1,2,0,2,1,2,2],[1,2,0,1,2,2,2],[1,1,2,2,2,2,0],[1,1,2,2,2,1,1],[1,1,2,2,2,0,2],[1,1,2,2,1,2,1],[1,1,2,2,1,1,2],[1,1,2,2,0,2,2],[1,1,2,1,2,2,1],[1,1,2,1,2,1,2],[1,1,2,1,1,2,2],[1,1,2,0,2,2,2],[1,1,1,2,2,2,1],[1,1,1,2,2,1,2],[1,1,1,2,1,2,2],[1,1,1,1,2,2,2],[1,1,0,2,2,2,2],[1,0,2,2,2,2,1],[1,0,2,2,2,1,2],[1,0,2,2,1,2,2],[1,0,2,1,2,2,2],[1,0,1,2,2,2,2],[0,2,2,2,2,2,0],[0,2,2,2,2,1,1],[0,2,2,2,2,0,2],[0,2,2,2,1,2,1],[0,2,2,2,1,1,2],[0,2,2,2,0,2,2],[0,2,2,1,2,2,1],[0,2,2,1,2,1,2],[0,2,2,1,1,2,2],[0,2,2,0,2,2,2],[0,2,1,2,2,2,1],[0,2,1,2,2,1,2],[0,2,1,2,1,2,2],[0,2,1,1,2,2,2],[0,2,0,2,2,2,2],[0,1,2,2,2,2,1],[0,1,2,2,2,1,2],[0,1,2,2,1,2,2],[0,1,2,1,2,2,2],[0,1,1,2,2,2,2],[0,0,2,2,2,2,2]]], + "(2, 2, 2, 2, 2, 1, 0)": [[1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,2,2,2,2,2,1,1,1,1,1,1,1],[[2,2,2,2,2,1,0],[2,2,2,2,2,0,1],[2,2,2,2,1,2,0],[2,2,2,2,1,1,1],[2,2,2,2,1,0,2],[2,2,2,2,0,2,1],[2,2,2,2,0,1,2],[2,2,2,1,2,2,0],[2,2,2,1,2,1,1],[2,2,2,1,2,0,2],[2,2,2,1,1,2,1],[2,2,2,1,1,1,2],[2,2,2,1,0,2,2],[2,2,2,0,2,2,1],[2,2,2,0,2,1,2],[2,2,2,0,1,2,2],[2,2,1,2,2,2,0],[2,2,1,2,2,1,1],[2,2,1,2,2,0,2],[2,2,1,2,1,2,1],[2,2,1,2,1,1,2],[2,2,1,2,0,2,2],[2,2,1,1,2,2,1],[2,2,1,1,2,1,2],[2,2,1,1,1,2,2],[2,2,1,0,2,2,2],[2,2,0,2,2,2,1],[2,2,0,2,2,1,2],[2,2,0,2,1,2,2],[2,2,0,1,2,2,2],[2,1,2,2,2,2,0],[2,1,2,2,2,1,1],[2,1,2,2,2,0,2],[2,1,2,2,1,2,1],[2,1,2,2,1,1,2],[2,1,2,2,0,2,2],[2,1,2,1,2,2,1],[2,1,2,1,2,1,2],[2,1,2,1,1,2,2],[2,1,2,0,2,2,2],[2,1,1,2,2,2,1],[2,1,1,2,2,1,2],[2,1,1,2,1,2,2],[2,1,1,1,2,2,2],[2,1,0,2,2,2,2],[2,0,2,2,2,2,1],[2,0,2,2,2,1,2],[2,0,2,2,1,2,2],[2,0,2,1,2,2,2],[2,0,1,2,2,2,2],[1,2,2,2,2,2,0],[1,2,2,2,2,1,1],[1,2,2,2,2,0,2],[1,2,2,2,1,2,1],[1,2,2,2,1,1,2],[1,2,2,2,0,2,2],[1,2,2,1,2,2,1],[1,2,2,1,2,1,2],[1,2,2,1,1,2,2],[1,2,2,0,2,2,2],[1,2,1,2,2,2,1],[1,2,1,2,2,1,2],[1,2,1,2,1,2,2],[1,2,1,1,2,2,2],[1,2,0,2,2,2,2],[1,1,2,2,2,2,1],[1,1,2,2,2,1,2],[1,1,2,2,1,2,2],[1,1,2,1,2,2,2],[1,1,1,2,2,2,2],[1,0,2,2,2,2,2],[0,2,2,2,2,2,1],[0,2,2,2,2,1,2],[0,2,2,2,1,2,2],[0,2,2,1,2,2,2],[0,2,1,2,2,2,2],[0,1,2,2,2,2,2]]], + "(2, 2, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,2,2,0],[2,2,2,2,2,1,1],[2,2,2,2,2,0,2],[2,2,2,2,1,2,1],[2,2,2,2,1,1,2],[2,2,2,2,0,2,2],[2,2,2,1,2,2,1],[2,2,2,1,2,1,2],[2,2,2,1,1,2,2],[2,2,2,0,2,2,2],[2,2,1,2,2,2,1],[2,2,1,2,2,1,2],[2,2,1,2,1,2,2],[2,2,1,1,2,2,2],[2,2,0,2,2,2,2],[2,1,2,2,2,2,1],[2,1,2,2,2,1,2],[2,1,2,2,1,2,2],[2,1,2,1,2,2,2],[2,1,1,2,2,2,2],[2,0,2,2,2,2,2],[1,2,2,2,2,2,1],[1,2,2,2,2,1,2],[1,2,2,2,1,2,2],[1,2,2,1,2,2,2],[1,2,1,2,2,2,2],[1,1,2,2,2,2,2],[0,2,2,2,2,2,2]]], + "(3, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,0,0,0,0,0,0],[2,1,0,0,0,0,0],[2,0,1,0,0,0,0],[2,0,0,1,0,0,0],[2,0,0,0,1,0,0],[2,0,0,0,0,1,0],[2,0,0,0,0,0,1],[1,2,0,0,0,0,0],[1,1,1,0,0,0,0],[1,1,0,1,0,0,0],[1,1,0,0,1,0,0],[1,1,0,0,0,1,0],[1,1,0,0,0,0,1],[1,0,2,0,0,0,0],[1,0,1,1,0,0,0],[1,0,1,0,1,0,0],[1,0,1,0,0,1,0],[1,0,1,0,0,0,1],[1,0,0,2,0,0,0],[1,0,0,1,1,0,0],[1,0,0,1,0,1,0],[1,0,0,1,0,0,1],[1,0,0,0,2,0,0],[1,0,0,0,1,1,0],[1,0,0,0,1,0,1],[1,0,0,0,0,2,0],[1,0,0,0,0,1,1],[1,0,0,0,0,0,2],[0,3,0,0,0,0,0],[0,2,1,0,0,0,0],[0,2,0,1,0,0,0],[0,2,0,0,1,0,0],[0,2,0,0,0,1,0],[0,2,0,0,0,0,1],[0,1,2,0,0,0,0],[0,1,1,1,0,0,0],[0,1,1,0,1,0,0],[0,1,1,0,0,1,0],[0,1,1,0,0,0,1],[0,1,0,2,0,0,0],[0,1,0,1,1,0,0],[0,1,0,1,0,1,0],[0,1,0,1,0,0,1],[0,1,0,0,2,0,0],[0,1,0,0,1,1,0],[0,1,0,0,1,0,1],[0,1,0,0,0,2,0],[0,1,0,0,0,1,1],[0,1,0,0,0,0,2],[0,0,3,0,0,0,0],[0,0,2,1,0,0,0],[0,0,2,0,1,0,0],[0,0,2,0,0,1,0],[0,0,2,0,0,0,1],[0,0,1,2,0,0,0],[0,0,1,1,1,0,0],[0,0,1,1,0,1,0],[0,0,1,1,0,0,1],[0,0,1,0,2,0,0],[0,0,1,0,1,1,0],[0,0,1,0,1,0,1],[0,0,1,0,0,2,0],[0,0,1,0,0,1,1],[0,0,1,0,0,0,2],[0,0,0,3,0,0,0],[0,0,0,2,1,0,0],[0,0,0,2,0,1,0],[0,0,0,2,0,0,1],[0,0,0,1,2,0,0],[0,0,0,1,1,1,0],[0,0,0,1,1,0,1],[0,0,0,1,0,2,0],[0,0,0,1,0,1,1],[0,0,0,1,0,0,2],[0,0,0,0,3,0,0],[0,0,0,0,2,1,0],[0,0,0,0,2,0,1],[0,0,0,0,1,2,0],[0,0,0,0,1,1,1],[0,0,0,0,1,0,2],[0,0,0,0,0,3,0],[0,0,0,0,0,2,1],[0,0,0,0,0,1,2],[0,0,0,0,0,0,3]]], + "(3, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,6,1,1,6,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,1,1,1,1,1,0],[3,1,1,1,1,0,1],[3,1,1,1,0,1,1],[3,1,1,0,1,1,1],[3,1,0,1,1,1,1],[3,0,1,1,1,1,1],[2,2,1,1,1,1,0],[2,2,1,1,1,0,1],[2,2,1,1,0,1,1],[2,2,1,0,1,1,1],[2,2,0,1,1,1,1],[2,1,2,1,1,1,0],[2,1,2,1,1,0,1],[2,1,2,1,0,1,1],[2,1,2,0,1,1,1],[2,1,1,2,1,1,0],[2,1,1,2,1,0,1],[2,1,1,2,0,1,1],[2,1,1,1,2,1,0],[2,1,1,1,2,0,1],[2,1,1,1,1,2,0],[2,1,1,1,1,1,1],[2,1,1,1,1,0,2],[2,1,1,1,0,2,1],[2,1,1,1,0,1,2],[2,1,1,0,2,1,1],[2,1,1,0,1,2,1],[2,1,1,0,1,1,2],[2,1,0,2,1,1,1],[2,1,0,1,2,1,1],[2,1,0,1,1,2,1],[2,1,0,1,1,1,2],[2,0,2,1,1,1,1],[2,0,1,2,1,1,1],[2,0,1,1,2,1,1],[2,0,1,1,1,2,1],[2,0,1,1,1,1,2],[1,3,1,1,1,1,0],[1,3,1,1,1,0,1],[1,3,1,1,0,1,1],[1,3,1,0,1,1,1],[1,3,0,1,1,1,1],[1,2,2,1,1,1,0],[1,2,2,1,1,0,1],[1,2,2,1,0,1,1],[1,2,2,0,1,1,1],[1,2,1,2,1,1,0],[1,2,1,2,1,0,1],[1,2,1,2,0,1,1],[1,2,1,1,2,1,0],[1,2,1,1,2,0,1],[1,2,1,1,1,2,0],[1,2,1,1,1,1,1],[1,2,1,1,1,0,2],[1,2,1,1,0,2,1],[1,2,1,1,0,1,2],[1,2,1,0,2,1,1],[1,2,1,0,1,2,1],[1,2,1,0,1,1,2],[1,2,0,2,1,1,1],[1,2,0,1,2,1,1],[1,2,0,1,1,2,1],[1,2,0,1,1,1,2],[1,1,3,1,1,1,0],[1,1,3,1,1,0,1],[1,1,3,1,0,1,1],[1,1,3,0,1,1,1],[1,1,2,2,1,1,0],[1,1,2,2,1,0,1],[1,1,2,2,0,1,1],[1,1,2,1,2,1,0],[1,1,2,1,2,0,1],[1,1,2,1,1,2,0],[1,1,2,1,1,1,1],[1,1,2,1,1,0,2],[1,1,2,1,0,2,1],[1,1,2,1,0,1,2],[1,1,2,0,2,1,1],[1,1,2,0,1,2,1],[1,1,2,0,1,1,2],[1,1,1,3,1,1,0],[1,1,1,3,1,0,1],[1,1,1,3,0,1,1],[1,1,1,2,2,1,0],[1,1,1,2,2,0,1],[1,1,1,2,1,2,0],[1,1,1,2,1,1,1],[1,1,1,2,1,0,2],[1,1,1,2,0,2,1],[1,1,1,2,0,1,2],[1,1,1,1,3,1,0],[1,1,1,1,3,0,1],[1,1,1,1,2,2,0],[1,1,1,1,2,1,1],[1,1,1,1,2,0,2],[1,1,1,1,1,3,0],[1,1,1,1,1,2,1],[1,1,1,1,1,1,2],[1,1,1,1,1,0,3],[1,1,1,1,0,3,1],[1,1,1,1,0,2,2],[1,1,1,1,0,1,3],[1,1,1,0,3,1,1],[1,1,1,0,2,2,1],[1,1,1,0,2,1,2],[1,1,1,0,1,3,1],[1,1,1,0,1,2,2],[1,1,1,0,1,1,3],[1,1,0,3,1,1,1],[1,1,0,2,2,1,1],[1,1,0,2,1,2,1],[1,1,0,2,1,1,2],[1,1,0,1,3,1,1],[1,1,0,1,2,2,1],[1,1,0,1,2,1,2],[1,1,0,1,1,3,1],[1,1,0,1,1,2,2],[1,1,0,1,1,1,3],[1,0,3,1,1,1,1],[1,0,2,2,1,1,1],[1,0,2,1,2,1,1],[1,0,2,1,1,2,1],[1,0,2,1,1,1,2],[1,0,1,3,1,1,1],[1,0,1,2,2,1,1],[1,0,1,2,1,2,1],[1,0,1,2,1,1,2],[1,0,1,1,3,1,1],[1,0,1,1,2,2,1],[1,0,1,1,2,1,2],[1,0,1,1,1,3,1],[1,0,1,1,1,2,2],[1,0,1,1,1,1,3],[0,3,1,1,1,1,1],[0,2,2,1,1,1,1],[0,2,1,2,1,1,1],[0,2,1,1,2,1,1],[0,2,1,1,1,2,1],[0,2,1,1,1,1,2],[0,1,3,1,1,1,1],[0,1,2,2,1,1,1],[0,1,2,1,2,1,1],[0,1,2,1,1,2,1],[0,1,2,1,1,1,2],[0,1,1,3,1,1,1],[0,1,1,2,2,1,1],[0,1,1,2,1,2,1],[0,1,1,2,1,1,2],[0,1,1,1,3,1,1],[0,1,1,1,2,2,1],[0,1,1,1,2,1,2],[0,1,1,1,1,3,1],[0,1,1,1,1,2,2],[0,1,1,1,1,1,3]]], + "(3, 2, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,6,1,1,6,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,2,2,2,2,2,0],[3,2,2,2,2,1,1],[3,2,2,2,2,0,2],[3,2,2,2,1,2,1],[3,2,2,2,1,1,2],[3,2,2,2,0,2,2],[3,2,2,1,2,2,1],[3,2,2,1,2,1,2],[3,2,2,1,1,2,2],[3,2,2,0,2,2,2],[3,2,1,2,2,2,1],[3,2,1,2,2,1,2],[3,2,1,2,1,2,2],[3,2,1,1,2,2,2],[3,2,0,2,2,2,2],[3,1,2,2,2,2,1],[3,1,2,2,2,1,2],[3,1,2,2,1,2,2],[3,1,2,1,2,2,2],[3,1,1,2,2,2,2],[3,0,2,2,2,2,2],[2,3,2,2,2,2,0],[2,3,2,2,2,1,1],[2,3,2,2,2,0,2],[2,3,2,2,1,2,1],[2,3,2,2,1,1,2],[2,3,2,2,0,2,2],[2,3,2,1,2,2,1],[2,3,2,1,2,1,2],[2,3,2,1,1,2,2],[2,3,2,0,2,2,2],[2,3,1,2,2,2,1],[2,3,1,2,2,1,2],[2,3,1,2,1,2,2],[2,3,1,1,2,2,2],[2,3,0,2,2,2,2],[2,2,3,2,2,2,0],[2,2,3,2,2,1,1],[2,2,3,2,2,0,2],[2,2,3,2,1,2,1],[2,2,3,2,1,1,2],[2,2,3,2,0,2,2],[2,2,3,1,2,2,1],[2,2,3,1,2,1,2],[2,2,3,1,1,2,2],[2,2,3,0,2,2,2],[2,2,2,3,2,2,0],[2,2,2,3,2,1,1],[2,2,2,3,2,0,2],[2,2,2,3,1,2,1],[2,2,2,3,1,1,2],[2,2,2,3,0,2,2],[2,2,2,2,3,2,0],[2,2,2,2,3,1,1],[2,2,2,2,3,0,2],[2,2,2,2,2,3,0],[2,2,2,2,2,2,1],[2,2,2,2,2,1,2],[2,2,2,2,2,0,3],[2,2,2,2,1,3,1],[2,2,2,2,1,2,2],[2,2,2,2,1,1,3],[2,2,2,2,0,3,2],[2,2,2,2,0,2,3],[2,2,2,1,3,2,1],[2,2,2,1,3,1,2],[2,2,2,1,2,3,1],[2,2,2,1,2,2,2],[2,2,2,1,2,1,3],[2,2,2,1,1,3,2],[2,2,2,1,1,2,3],[2,2,2,0,3,2,2],[2,2,2,0,2,3,2],[2,2,2,0,2,2,3],[2,2,1,3,2,2,1],[2,2,1,3,2,1,2],[2,2,1,3,1,2,2],[2,2,1,2,3,2,1],[2,2,1,2,3,1,2],[2,2,1,2,2,3,1],[2,2,1,2,2,2,2],[2,2,1,2,2,1,3],[2,2,1,2,1,3,2],[2,2,1,2,1,2,3],[2,2,1,1,3,2,2],[2,2,1,1,2,3,2],[2,2,1,1,2,2,3],[2,2,0,3,2,2,2],[2,2,0,2,3,2,2],[2,2,0,2,2,3,2],[2,2,0,2,2,2,3],[2,1,3,2,2,2,1],[2,1,3,2,2,1,2],[2,1,3,2,1,2,2],[2,1,3,1,2,2,2],[2,1,2,3,2,2,1],[2,1,2,3,2,1,2],[2,1,2,3,1,2,2],[2,1,2,2,3,2,1],[2,1,2,2,3,1,2],[2,1,2,2,2,3,1],[2,1,2,2,2,2,2],[2,1,2,2,2,1,3],[2,1,2,2,1,3,2],[2,1,2,2,1,2,3],[2,1,2,1,3,2,2],[2,1,2,1,2,3,2],[2,1,2,1,2,2,3],[2,1,1,3,2,2,2],[2,1,1,2,3,2,2],[2,1,1,2,2,3,2],[2,1,1,2,2,2,3],[2,0,3,2,2,2,2],[2,0,2,3,2,2,2],[2,0,2,2,3,2,2],[2,0,2,2,2,3,2],[2,0,2,2,2,2,3],[1,3,2,2,2,2,1],[1,3,2,2,2,1,2],[1,3,2,2,1,2,2],[1,3,2,1,2,2,2],[1,3,1,2,2,2,2],[1,2,3,2,2,2,1],[1,2,3,2,2,1,2],[1,2,3,2,1,2,2],[1,2,3,1,2,2,2],[1,2,2,3,2,2,1],[1,2,2,3,2,1,2],[1,2,2,3,1,2,2],[1,2,2,2,3,2,1],[1,2,2,2,3,1,2],[1,2,2,2,2,3,1],[1,2,2,2,2,2,2],[1,2,2,2,2,1,3],[1,2,2,2,1,3,2],[1,2,2,2,1,2,3],[1,2,2,1,3,2,2],[1,2,2,1,2,3,2],[1,2,2,1,2,2,3],[1,2,1,3,2,2,2],[1,2,1,2,3,2,2],[1,2,1,2,2,3,2],[1,2,1,2,2,2,3],[1,1,3,2,2,2,2],[1,1,2,3,2,2,2],[1,1,2,2,3,2,2],[1,1,2,2,2,3,2],[1,1,2,2,2,2,3],[0,3,2,2,2,2,2],[0,2,3,2,2,2,2],[0,2,2,3,2,2,2],[0,2,2,2,3,2,2],[0,2,2,2,2,3,2],[0,2,2,2,2,2,3]]], + "(3, 3, 3, 3, 3, 3, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[3,3,3,3,3,3,0],[3,3,3,3,3,2,1],[3,3,3,3,3,1,2],[3,3,3,3,3,0,3],[3,3,3,3,2,3,1],[3,3,3,3,2,2,2],[3,3,3,3,2,1,3],[3,3,3,3,1,3,2],[3,3,3,3,1,2,3],[3,3,3,3,0,3,3],[3,3,3,2,3,3,1],[3,3,3,2,3,2,2],[3,3,3,2,3,1,3],[3,3,3,2,2,3,2],[3,3,3,2,2,2,3],[3,3,3,2,1,3,3],[3,3,3,1,3,3,2],[3,3,3,1,3,2,3],[3,3,3,1,2,3,3],[3,3,3,0,3,3,3],[3,3,2,3,3,3,1],[3,3,2,3,3,2,2],[3,3,2,3,3,1,3],[3,3,2,3,2,3,2],[3,3,2,3,2,2,3],[3,3,2,3,1,3,3],[3,3,2,2,3,3,2],[3,3,2,2,3,2,3],[3,3,2,2,2,3,3],[3,3,2,1,3,3,3],[3,3,1,3,3,3,2],[3,3,1,3,3,2,3],[3,3,1,3,2,3,3],[3,3,1,2,3,3,3],[3,3,0,3,3,3,3],[3,2,3,3,3,3,1],[3,2,3,3,3,2,2],[3,2,3,3,3,1,3],[3,2,3,3,2,3,2],[3,2,3,3,2,2,3],[3,2,3,3,1,3,3],[3,2,3,2,3,3,2],[3,2,3,2,3,2,3],[3,2,3,2,2,3,3],[3,2,3,1,3,3,3],[3,2,2,3,3,3,2],[3,2,2,3,3,2,3],[3,2,2,3,2,3,3],[3,2,2,2,3,3,3],[3,2,1,3,3,3,3],[3,1,3,3,3,3,2],[3,1,3,3,3,2,3],[3,1,3,3,2,3,3],[3,1,3,2,3,3,3],[3,1,2,3,3,3,3],[3,0,3,3,3,3,3],[2,3,3,3,3,3,1],[2,3,3,3,3,2,2],[2,3,3,3,3,1,3],[2,3,3,3,2,3,2],[2,3,3,3,2,2,3],[2,3,3,3,1,3,3],[2,3,3,2,3,3,2],[2,3,3,2,3,2,3],[2,3,3,2,2,3,3],[2,3,3,1,3,3,3],[2,3,2,3,3,3,2],[2,3,2,3,3,2,3],[2,3,2,3,2,3,3],[2,3,2,2,3,3,3],[2,3,1,3,3,3,3],[2,2,3,3,3,3,2],[2,2,3,3,3,2,3],[2,2,3,3,2,3,3],[2,2,3,2,3,3,3],[2,2,2,3,3,3,3],[2,1,3,3,3,3,3],[1,3,3,3,3,3,2],[1,3,3,3,3,2,3],[1,3,3,3,2,3,3],[1,3,3,2,3,3,3],[1,3,2,3,3,3,3],[1,2,3,3,3,3,3],[0,3,3,3,3,3,3]]] + }, + "SU(8)": { + "(0, 0, 0, 0, 0, 0, 0, 0)": [[1],[[0,0,0,0,0,0,0,0]]], + "(1, 0, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1],[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]]], + "(1, 1, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,1,1]]], + "(1, 1, 1, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,1,1,0,0,0,0],[1,0,1,0,1,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,0],[1,0,1,0,0,0,0,1],[1,0,0,1,1,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,1],[1,0,0,0,1,1,0,0],[1,0,0,0,1,0,1,0],[1,0,0,0,1,0,0,1],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,1,1],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,1,0,0],[0,1,1,0,0,0,1,0],[0,1,1,0,0,0,0,1],[0,1,0,1,1,0,0,0],[0,1,0,1,0,1,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,1],[0,1,0,0,1,1,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,1,1,0],[0,1,0,0,0,1,0,1],[0,1,0,0,0,0,1,1],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,1,0],[0,0,1,1,0,0,0,1],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,1,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,1,1,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,1,1],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,1],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,1],[0,0,0,1,0,0,1,1],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,1,1],[0,0,0,0,0,1,1,1]]], + "(1, 1, 1, 1, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,0,0,0,0],[1,1,1,0,1,0,0,0],[1,1,1,0,0,1,0,0],[1,1,1,0,0,0,1,0],[1,1,1,0,0,0,0,1],[1,1,0,1,1,0,0,0],[1,1,0,1,0,1,0,0],[1,1,0,1,0,0,1,0],[1,1,0,1,0,0,0,1],[1,1,0,0,1,1,0,0],[1,1,0,0,1,0,1,0],[1,1,0,0,1,0,0,1],[1,1,0,0,0,1,1,0],[1,1,0,0,0,1,0,1],[1,1,0,0,0,0,1,1],[1,0,1,1,1,0,0,0],[1,0,1,1,0,1,0,0],[1,0,1,1,0,0,1,0],[1,0,1,1,0,0,0,1],[1,0,1,0,1,1,0,0],[1,0,1,0,1,0,1,0],[1,0,1,0,1,0,0,1],[1,0,1,0,0,1,1,0],[1,0,1,0,0,1,0,1],[1,0,1,0,0,0,1,1],[1,0,0,1,1,1,0,0],[1,0,0,1,1,0,1,0],[1,0,0,1,1,0,0,1],[1,0,0,1,0,1,1,0],[1,0,0,1,0,1,0,1],[1,0,0,1,0,0,1,1],[1,0,0,0,1,1,1,0],[1,0,0,0,1,1,0,1],[1,0,0,0,1,0,1,1],[1,0,0,0,0,1,1,1],[0,1,1,1,1,0,0,0],[0,1,1,1,0,1,0,0],[0,1,1,1,0,0,1,0],[0,1,1,1,0,0,0,1],[0,1,1,0,1,1,0,0],[0,1,1,0,1,0,1,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,1,1,0],[0,1,1,0,0,1,0,1],[0,1,1,0,0,0,1,1],[0,1,0,1,1,1,0,0],[0,1,0,1,1,0,1,0],[0,1,0,1,1,0,0,1],[0,1,0,1,0,1,1,0],[0,1,0,1,0,1,0,1],[0,1,0,1,0,0,1,1],[0,1,0,0,1,1,1,0],[0,1,0,0,1,1,0,1],[0,1,0,0,1,0,1,1],[0,1,0,0,0,1,1,1],[0,0,1,1,1,1,0,0],[0,0,1,1,1,0,1,0],[0,0,1,1,1,0,0,1],[0,0,1,1,0,1,1,0],[0,0,1,1,0,1,0,1],[0,0,1,1,0,0,1,1],[0,0,1,0,1,1,1,0],[0,0,1,0,1,1,0,1],[0,0,1,0,1,0,1,1],[0,0,1,0,0,1,1,1],[0,0,0,1,1,1,1,0],[0,0,0,1,1,1,0,1],[0,0,0,1,1,0,1,1],[0,0,0,1,0,1,1,1],[0,0,0,0,1,1,1,1]]], + "(1, 1, 1, 1, 1, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,0,0,0],[1,1,1,1,0,1,0,0],[1,1,1,1,0,0,1,0],[1,1,1,1,0,0,0,1],[1,1,1,0,1,1,0,0],[1,1,1,0,1,0,1,0],[1,1,1,0,1,0,0,1],[1,1,1,0,0,1,1,0],[1,1,1,0,0,1,0,1],[1,1,1,0,0,0,1,1],[1,1,0,1,1,1,0,0],[1,1,0,1,1,0,1,0],[1,1,0,1,1,0,0,1],[1,1,0,1,0,1,1,0],[1,1,0,1,0,1,0,1],[1,1,0,1,0,0,1,1],[1,1,0,0,1,1,1,0],[1,1,0,0,1,1,0,1],[1,1,0,0,1,0,1,1],[1,1,0,0,0,1,1,1],[1,0,1,1,1,1,0,0],[1,0,1,1,1,0,1,0],[1,0,1,1,1,0,0,1],[1,0,1,1,0,1,1,0],[1,0,1,1,0,1,0,1],[1,0,1,1,0,0,1,1],[1,0,1,0,1,1,1,0],[1,0,1,0,1,1,0,1],[1,0,1,0,1,0,1,1],[1,0,1,0,0,1,1,1],[1,0,0,1,1,1,1,0],[1,0,0,1,1,1,0,1],[1,0,0,1,1,0,1,1],[1,0,0,1,0,1,1,1],[1,0,0,0,1,1,1,1],[0,1,1,1,1,1,0,0],[0,1,1,1,1,0,1,0],[0,1,1,1,1,0,0,1],[0,1,1,1,0,1,1,0],[0,1,1,1,0,1,0,1],[0,1,1,1,0,0,1,1],[0,1,1,0,1,1,1,0],[0,1,1,0,1,1,0,1],[0,1,1,0,1,0,1,1],[0,1,1,0,0,1,1,1],[0,1,0,1,1,1,1,0],[0,1,0,1,1,1,0,1],[0,1,0,1,1,0,1,1],[0,1,0,1,0,1,1,1],[0,1,0,0,1,1,1,1],[0,0,1,1,1,1,1,0],[0,0,1,1,1,1,0,1],[0,0,1,1,1,0,1,1],[0,0,1,1,0,1,1,1],[0,0,1,0,1,1,1,1],[0,0,0,1,1,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,1,0,0],[1,1,1,1,1,0,1,0],[1,1,1,1,1,0,0,1],[1,1,1,1,0,1,1,0],[1,1,1,1,0,1,0,1],[1,1,1,1,0,0,1,1],[1,1,1,0,1,1,1,0],[1,1,1,0,1,1,0,1],[1,1,1,0,1,0,1,1],[1,1,1,0,0,1,1,1],[1,1,0,1,1,1,1,0],[1,1,0,1,1,1,0,1],[1,1,0,1,1,0,1,1],[1,1,0,1,0,1,1,1],[1,1,0,0,1,1,1,1],[1,0,1,1,1,1,1,0],[1,0,1,1,1,1,0,1],[1,0,1,1,1,0,1,1],[1,0,1,1,0,1,1,1],[1,0,1,0,1,1,1,1],[1,0,0,1,1,1,1,1],[0,1,1,1,1,1,1,0],[0,1,1,1,1,1,0,1],[0,1,1,1,1,0,1,1],[0,1,1,1,0,1,1,1],[0,1,1,0,1,1,1,1],[0,1,0,1,1,1,1,1],[0,0,1,1,1,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1],[[1,1,1,1,1,1,1,0],[1,1,1,1,1,1,0,1],[1,1,1,1,1,0,1,1],[1,1,1,1,0,1,1,1],[1,1,1,0,1,1,1,1],[1,1,0,1,1,1,1,1],[1,0,1,1,1,1,1,1],[0,1,1,1,1,1,1,1]]], + "(2, 0, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1],[0,0,0,2,0,0,0,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,2]]], + "(2, 1, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,2,2,2,2,2,2,1,2,2,2,2,2,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,1,1,2,2,2,2,2,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,1,2,2,2,2,1,2,2,2,1,2,2,1,2,1,1,1,1,1,1,2,2,2,1,2,2,1,2,1,1,1,1,1,2,2,1,2,1,1,1,1,2,1,1,1],[[2,1,0,0,0,0,0,0],[2,0,1,0,0,0,0,0],[2,0,0,1,0,0,0,0],[2,0,0,0,1,0,0,0],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[1,2,0,0,0,0,0,0],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,0,2,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,1,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,0],[1,0,1,0,0,0,0,1],[1,0,0,2,0,0,0,0],[1,0,0,1,1,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,1],[1,0,0,0,2,0,0,0],[1,0,0,0,1,1,0,0],[1,0,0,0,1,0,1,0],[1,0,0,0,1,0,0,1],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,0,2],[0,2,1,0,0,0,0,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,0,0],[0,2,0,0,0,1,0,0],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,1,2,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,1,0,0],[0,1,1,0,0,0,1,0],[0,1,1,0,0,0,0,1],[0,1,0,2,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,1,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,1],[0,1,0,0,2,0,0,0],[0,1,0,0,1,1,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,0,2,0,0],[0,1,0,0,0,1,1,0],[0,1,0,0,0,1,0,1],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,0,2],[0,0,2,1,0,0,0,0],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,1,0],[0,0,2,0,0,0,0,1],[0,0,1,2,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,1,0],[0,0,1,1,0,0,0,1],[0,0,1,0,2,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,1,0],[0,0,1,0,1,0,0,1],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,1,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,0,2,0],[0,0,1,0,0,0,1,1],[0,0,1,0,0,0,0,2],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,1],[0,0,0,1,2,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,1],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,1],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,1],[0,0,0,1,0,0,0,2],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,0,2],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,0,2],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,1,2]]], + "(2, 1, 1, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,6,1,6,1,1,1,1,6,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,1,0,0],[2,1,1,1,1,0,1,0],[2,1,1,1,1,0,0,1],[2,1,1,1,0,1,1,0],[2,1,1,1,0,1,0,1],[2,1,1,1,0,0,1,1],[2,1,1,0,1,1,1,0],[2,1,1,0,1,1,0,1],[2,1,1,0,1,0,1,1],[2,1,1,0,0,1,1,1],[2,1,0,1,1,1,1,0],[2,1,0,1,1,1,0,1],[2,1,0,1,1,0,1,1],[2,1,0,1,0,1,1,1],[2,1,0,0,1,1,1,1],[2,0,1,1,1,1,1,0],[2,0,1,1,1,1,0,1],[2,0,1,1,1,0,1,1],[2,0,1,1,0,1,1,1],[2,0,1,0,1,1,1,1],[2,0,0,1,1,1,1,1],[1,2,1,1,1,1,0,0],[1,2,1,1,1,0,1,0],[1,2,1,1,1,0,0,1],[1,2,1,1,0,1,1,0],[1,2,1,1,0,1,0,1],[1,2,1,1,0,0,1,1],[1,2,1,0,1,1,1,0],[1,2,1,0,1,1,0,1],[1,2,1,0,1,0,1,1],[1,2,1,0,0,1,1,1],[1,2,0,1,1,1,1,0],[1,2,0,1,1,1,0,1],[1,2,0,1,1,0,1,1],[1,2,0,1,0,1,1,1],[1,2,0,0,1,1,1,1],[1,1,2,1,1,1,0,0],[1,1,2,1,1,0,1,0],[1,1,2,1,1,0,0,1],[1,1,2,1,0,1,1,0],[1,1,2,1,0,1,0,1],[1,1,2,1,0,0,1,1],[1,1,2,0,1,1,1,0],[1,1,2,0,1,1,0,1],[1,1,2,0,1,0,1,1],[1,1,2,0,0,1,1,1],[1,1,1,2,1,1,0,0],[1,1,1,2,1,0,1,0],[1,1,1,2,1,0,0,1],[1,1,1,2,0,1,1,0],[1,1,1,2,0,1,0,1],[1,1,1,2,0,0,1,1],[1,1,1,1,2,1,0,0],[1,1,1,1,2,0,1,0],[1,1,1,1,2,0,0,1],[1,1,1,1,1,2,0,0],[1,1,1,1,1,1,1,0],[1,1,1,1,1,1,0,1],[1,1,1,1,1,0,2,0],[1,1,1,1,1,0,1,1],[1,1,1,1,1,0,0,2],[1,1,1,1,0,2,1,0],[1,1,1,1,0,2,0,1],[1,1,1,1,0,1,2,0],[1,1,1,1,0,1,1,1],[1,1,1,1,0,1,0,2],[1,1,1,1,0,0,2,1],[1,1,1,1,0,0,1,2],[1,1,1,0,2,1,1,0],[1,1,1,0,2,1,0,1],[1,1,1,0,2,0,1,1],[1,1,1,0,1,2,1,0],[1,1,1,0,1,2,0,1],[1,1,1,0,1,1,2,0],[1,1,1,0,1,1,1,1],[1,1,1,0,1,1,0,2],[1,1,1,0,1,0,2,1],[1,1,1,0,1,0,1,2],[1,1,1,0,0,2,1,1],[1,1,1,0,0,1,2,1],[1,1,1,0,0,1,1,2],[1,1,0,2,1,1,1,0],[1,1,0,2,1,1,0,1],[1,1,0,2,1,0,1,1],[1,1,0,2,0,1,1,1],[1,1,0,1,2,1,1,0],[1,1,0,1,2,1,0,1],[1,1,0,1,2,0,1,1],[1,1,0,1,1,2,1,0],[1,1,0,1,1,2,0,1],[1,1,0,1,1,1,2,0],[1,1,0,1,1,1,1,1],[1,1,0,1,1,1,0,2],[1,1,0,1,1,0,2,1],[1,1,0,1,1,0,1,2],[1,1,0,1,0,2,1,1],[1,1,0,1,0,1,2,1],[1,1,0,1,0,1,1,2],[1,1,0,0,2,1,1,1],[1,1,0,0,1,2,1,1],[1,1,0,0,1,1,2,1],[1,1,0,0,1,1,1,2],[1,0,2,1,1,1,1,0],[1,0,2,1,1,1,0,1],[1,0,2,1,1,0,1,1],[1,0,2,1,0,1,1,1],[1,0,2,0,1,1,1,1],[1,0,1,2,1,1,1,0],[1,0,1,2,1,1,0,1],[1,0,1,2,1,0,1,1],[1,0,1,2,0,1,1,1],[1,0,1,1,2,1,1,0],[1,0,1,1,2,1,0,1],[1,0,1,1,2,0,1,1],[1,0,1,1,1,2,1,0],[1,0,1,1,1,2,0,1],[1,0,1,1,1,1,2,0],[1,0,1,1,1,1,1,1],[1,0,1,1,1,1,0,2],[1,0,1,1,1,0,2,1],[1,0,1,1,1,0,1,2],[1,0,1,1,0,2,1,1],[1,0,1,1,0,1,2,1],[1,0,1,1,0,1,1,2],[1,0,1,0,2,1,1,1],[1,0,1,0,1,2,1,1],[1,0,1,0,1,1,2,1],[1,0,1,0,1,1,1,2],[1,0,0,2,1,1,1,1],[1,0,0,1,2,1,1,1],[1,0,0,1,1,2,1,1],[1,0,0,1,1,1,2,1],[1,0,0,1,1,1,1,2],[0,2,1,1,1,1,1,0],[0,2,1,1,1,1,0,1],[0,2,1,1,1,0,1,1],[0,2,1,1,0,1,1,1],[0,2,1,0,1,1,1,1],[0,2,0,1,1,1,1,1],[0,1,2,1,1,1,1,0],[0,1,2,1,1,1,0,1],[0,1,2,1,1,0,1,1],[0,1,2,1,0,1,1,1],[0,1,2,0,1,1,1,1],[0,1,1,2,1,1,1,0],[0,1,1,2,1,1,0,1],[0,1,1,2,1,0,1,1],[0,1,1,2,0,1,1,1],[0,1,1,1,2,1,1,0],[0,1,1,1,2,1,0,1],[0,1,1,1,2,0,1,1],[0,1,1,1,1,2,1,0],[0,1,1,1,1,2,0,1],[0,1,1,1,1,1,2,0],[0,1,1,1,1,1,1,1],[0,1,1,1,1,1,0,2],[0,1,1,1,1,0,2,1],[0,1,1,1,1,0,1,2],[0,1,1,1,0,2,1,1],[0,1,1,1,0,1,2,1],[0,1,1,1,0,1,1,2],[0,1,1,0,2,1,1,1],[0,1,1,0,1,2,1,1],[0,1,1,0,1,1,2,1],[0,1,1,0,1,1,1,2],[0,1,0,2,1,1,1,1],[0,1,0,1,2,1,1,1],[0,1,0,1,1,2,1,1],[0,1,0,1,1,1,2,1],[0,1,0,1,1,1,1,2],[0,0,2,1,1,1,1,1],[0,0,1,2,1,1,1,1],[0,0,1,1,2,1,1,1],[0,0,1,1,1,2,1,1],[0,0,1,1,1,1,2,1],[0,0,1,1,1,1,1,2]]], + "(2, 1, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,1,1,0],[2,1,1,1,1,1,0,1],[2,1,1,1,1,0,1,1],[2,1,1,1,0,1,1,1],[2,1,1,0,1,1,1,1],[2,1,0,1,1,1,1,1],[2,0,1,1,1,1,1,1],[1,2,1,1,1,1,1,0],[1,2,1,1,1,1,0,1],[1,2,1,1,1,0,1,1],[1,2,1,1,0,1,1,1],[1,2,1,0,1,1,1,1],[1,2,0,1,1,1,1,1],[1,1,2,1,1,1,1,0],[1,1,2,1,1,1,0,1],[1,1,2,1,1,0,1,1],[1,1,2,1,0,1,1,1],[1,1,2,0,1,1,1,1],[1,1,1,2,1,1,1,0],[1,1,1,2,1,1,0,1],[1,1,1,2,1,0,1,1],[1,1,1,2,0,1,1,1],[1,1,1,1,2,1,1,0],[1,1,1,1,2,1,0,1],[1,1,1,1,2,0,1,1],[1,1,1,1,1,2,1,0],[1,1,1,1,1,2,0,1],[1,1,1,1,1,1,2,0],[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,0,2],[1,1,1,1,1,0,2,1],[1,1,1,1,1,0,1,2],[1,1,1,1,0,2,1,1],[1,1,1,1,0,1,2,1],[1,1,1,1,0,1,1,2],[1,1,1,0,2,1,1,1],[1,1,1,0,1,2,1,1],[1,1,1,0,1,1,2,1],[1,1,1,0,1,1,1,2],[1,1,0,2,1,1,1,1],[1,1,0,1,2,1,1,1],[1,1,0,1,1,2,1,1],[1,1,0,1,1,1,2,1],[1,1,0,1,1,1,1,2],[1,0,2,1,1,1,1,1],[1,0,1,2,1,1,1,1],[1,0,1,1,2,1,1,1],[1,0,1,1,1,2,1,1],[1,0,1,1,1,1,2,1],[1,0,1,1,1,1,1,2],[0,2,1,1,1,1,1,1],[0,1,2,1,1,1,1,1],[0,1,1,2,1,1,1,1],[0,1,1,1,2,1,1,1],[0,1,1,1,1,2,1,1],[0,1,1,1,1,1,2,1],[0,1,1,1,1,1,1,2]]], + "(2, 2, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,6,1,1,1,1,6,1,6,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,1,1,1,1,1,0],[2,2,1,1,1,1,0,1],[2,2,1,1,1,0,1,1],[2,2,1,1,0,1,1,1],[2,2,1,0,1,1,1,1],[2,2,0,1,1,1,1,1],[2,1,2,1,1,1,1,0],[2,1,2,1,1,1,0,1],[2,1,2,1,1,0,1,1],[2,1,2,1,0,1,1,1],[2,1,2,0,1,1,1,1],[2,1,1,2,1,1,1,0],[2,1,1,2,1,1,0,1],[2,1,1,2,1,0,1,1],[2,1,1,2,0,1,1,1],[2,1,1,1,2,1,1,0],[2,1,1,1,2,1,0,1],[2,1,1,1,2,0,1,1],[2,1,1,1,1,2,1,0],[2,1,1,1,1,2,0,1],[2,1,1,1,1,1,2,0],[2,1,1,1,1,1,1,1],[2,1,1,1,1,1,0,2],[2,1,1,1,1,0,2,1],[2,1,1,1,1,0,1,2],[2,1,1,1,0,2,1,1],[2,1,1,1,0,1,2,1],[2,1,1,1,0,1,1,2],[2,1,1,0,2,1,1,1],[2,1,1,0,1,2,1,1],[2,1,1,0,1,1,2,1],[2,1,1,0,1,1,1,2],[2,1,0,2,1,1,1,1],[2,1,0,1,2,1,1,1],[2,1,0,1,1,2,1,1],[2,1,0,1,1,1,2,1],[2,1,0,1,1,1,1,2],[2,0,2,1,1,1,1,1],[2,0,1,2,1,1,1,1],[2,0,1,1,2,1,1,1],[2,0,1,1,1,2,1,1],[2,0,1,1,1,1,2,1],[2,0,1,1,1,1,1,2],[1,2,2,1,1,1,1,0],[1,2,2,1,1,1,0,1],[1,2,2,1,1,0,1,1],[1,2,2,1,0,1,1,1],[1,2,2,0,1,1,1,1],[1,2,1,2,1,1,1,0],[1,2,1,2,1,1,0,1],[1,2,1,2,1,0,1,1],[1,2,1,2,0,1,1,1],[1,2,1,1,2,1,1,0],[1,2,1,1,2,1,0,1],[1,2,1,1,2,0,1,1],[1,2,1,1,1,2,1,0],[1,2,1,1,1,2,0,1],[1,2,1,1,1,1,2,0],[1,2,1,1,1,1,1,1],[1,2,1,1,1,1,0,2],[1,2,1,1,1,0,2,1],[1,2,1,1,1,0,1,2],[1,2,1,1,0,2,1,1],[1,2,1,1,0,1,2,1],[1,2,1,1,0,1,1,2],[1,2,1,0,2,1,1,1],[1,2,1,0,1,2,1,1],[1,2,1,0,1,1,2,1],[1,2,1,0,1,1,1,2],[1,2,0,2,1,1,1,1],[1,2,0,1,2,1,1,1],[1,2,0,1,1,2,1,1],[1,2,0,1,1,1,2,1],[1,2,0,1,1,1,1,2],[1,1,2,2,1,1,1,0],[1,1,2,2,1,1,0,1],[1,1,2,2,1,0,1,1],[1,1,2,2,0,1,1,1],[1,1,2,1,2,1,1,0],[1,1,2,1,2,1,0,1],[1,1,2,1,2,0,1,1],[1,1,2,1,1,2,1,0],[1,1,2,1,1,2,0,1],[1,1,2,1,1,1,2,0],[1,1,2,1,1,1,1,1],[1,1,2,1,1,1,0,2],[1,1,2,1,1,0,2,1],[1,1,2,1,1,0,1,2],[1,1,2,1,0,2,1,1],[1,1,2,1,0,1,2,1],[1,1,2,1,0,1,1,2],[1,1,2,0,2,1,1,1],[1,1,2,0,1,2,1,1],[1,1,2,0,1,1,2,1],[1,1,2,0,1,1,1,2],[1,1,1,2,2,1,1,0],[1,1,1,2,2,1,0,1],[1,1,1,2,2,0,1,1],[1,1,1,2,1,2,1,0],[1,1,1,2,1,2,0,1],[1,1,1,2,1,1,2,0],[1,1,1,2,1,1,1,1],[1,1,1,2,1,1,0,2],[1,1,1,2,1,0,2,1],[1,1,1,2,1,0,1,2],[1,1,1,2,0,2,1,1],[1,1,1,2,0,1,2,1],[1,1,1,2,0,1,1,2],[1,1,1,1,2,2,1,0],[1,1,1,1,2,2,0,1],[1,1,1,1,2,1,2,0],[1,1,1,1,2,1,1,1],[1,1,1,1,2,1,0,2],[1,1,1,1,2,0,2,1],[1,1,1,1,2,0,1,2],[1,1,1,1,1,2,2,0],[1,1,1,1,1,2,1,1],[1,1,1,1,1,2,0,2],[1,1,1,1,1,1,2,1],[1,1,1,1,1,1,1,2],[1,1,1,1,1,0,2,2],[1,1,1,1,0,2,2,1],[1,1,1,1,0,2,1,2],[1,1,1,1,0,1,2,2],[1,1,1,0,2,2,1,1],[1,1,1,0,2,1,2,1],[1,1,1,0,2,1,1,2],[1,1,1,0,1,2,2,1],[1,1,1,0,1,2,1,2],[1,1,1,0,1,1,2,2],[1,1,0,2,2,1,1,1],[1,1,0,2,1,2,1,1],[1,1,0,2,1,1,2,1],[1,1,0,2,1,1,1,2],[1,1,0,1,2,2,1,1],[1,1,0,1,2,1,2,1],[1,1,0,1,2,1,1,2],[1,1,0,1,1,2,2,1],[1,1,0,1,1,2,1,2],[1,1,0,1,1,1,2,2],[1,0,2,2,1,1,1,1],[1,0,2,1,2,1,1,1],[1,0,2,1,1,2,1,1],[1,0,2,1,1,1,2,1],[1,0,2,1,1,1,1,2],[1,0,1,2,2,1,1,1],[1,0,1,2,1,2,1,1],[1,0,1,2,1,1,2,1],[1,0,1,2,1,1,1,2],[1,0,1,1,2,2,1,1],[1,0,1,1,2,1,2,1],[1,0,1,1,2,1,1,2],[1,0,1,1,1,2,2,1],[1,0,1,1,1,2,1,2],[1,0,1,1,1,1,2,2],[0,2,2,1,1,1,1,1],[0,2,1,2,1,1,1,1],[0,2,1,1,2,1,1,1],[0,2,1,1,1,2,1,1],[0,2,1,1,1,1,2,1],[0,2,1,1,1,1,1,2],[0,1,2,2,1,1,1,1],[0,1,2,1,2,1,1,1],[0,1,2,1,1,2,1,1],[0,1,2,1,1,1,2,1],[0,1,2,1,1,1,1,2],[0,1,1,2,2,1,1,1],[0,1,1,2,1,2,1,1],[0,1,1,2,1,1,2,1],[0,1,1,2,1,1,1,2],[0,1,1,1,2,2,1,1],[0,1,1,1,2,1,2,1],[0,1,1,1,2,1,1,2],[0,1,1,1,1,2,2,1],[0,1,1,1,1,2,1,2],[0,1,1,1,1,1,2,2]]], + "(2, 2, 2, 2, 2, 2, 1, 0)": [[1,1,1,2,1,1,1,1,2,1,2,2,1,1,1,1,1,2,1,2,2,1,2,2,2,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,2,2,2,2,2,1,1,1,1,1,1,1,1,2,1,2,2,1,2,2,2,1,2,2,2,2,1,2,2,2,2,2,1,2,2,2,2,2,2,1,1,1,1,1,1,1,1],[[2,2,2,2,2,2,1,0],[2,2,2,2,2,2,0,1],[2,2,2,2,2,1,2,0],[2,2,2,2,2,1,1,1],[2,2,2,2,2,1,0,2],[2,2,2,2,2,0,2,1],[2,2,2,2,2,0,1,2],[2,2,2,2,1,2,2,0],[2,2,2,2,1,2,1,1],[2,2,2,2,1,2,0,2],[2,2,2,2,1,1,2,1],[2,2,2,2,1,1,1,2],[2,2,2,2,1,0,2,2],[2,2,2,2,0,2,2,1],[2,2,2,2,0,2,1,2],[2,2,2,2,0,1,2,2],[2,2,2,1,2,2,2,0],[2,2,2,1,2,2,1,1],[2,2,2,1,2,2,0,2],[2,2,2,1,2,1,2,1],[2,2,2,1,2,1,1,2],[2,2,2,1,2,0,2,2],[2,2,2,1,1,2,2,1],[2,2,2,1,1,2,1,2],[2,2,2,1,1,1,2,2],[2,2,2,1,0,2,2,2],[2,2,2,0,2,2,2,1],[2,2,2,0,2,2,1,2],[2,2,2,0,2,1,2,2],[2,2,2,0,1,2,2,2],[2,2,1,2,2,2,2,0],[2,2,1,2,2,2,1,1],[2,2,1,2,2,2,0,2],[2,2,1,2,2,1,2,1],[2,2,1,2,2,1,1,2],[2,2,1,2,2,0,2,2],[2,2,1,2,1,2,2,1],[2,2,1,2,1,2,1,2],[2,2,1,2,1,1,2,2],[2,2,1,2,0,2,2,2],[2,2,1,1,2,2,2,1],[2,2,1,1,2,2,1,2],[2,2,1,1,2,1,2,2],[2,2,1,1,1,2,2,2],[2,2,1,0,2,2,2,2],[2,2,0,2,2,2,2,1],[2,2,0,2,2,2,1,2],[2,2,0,2,2,1,2,2],[2,2,0,2,1,2,2,2],[2,2,0,1,2,2,2,2],[2,1,2,2,2,2,2,0],[2,1,2,2,2,2,1,1],[2,1,2,2,2,2,0,2],[2,1,2,2,2,1,2,1],[2,1,2,2,2,1,1,2],[2,1,2,2,2,0,2,2],[2,1,2,2,1,2,2,1],[2,1,2,2,1,2,1,2],[2,1,2,2,1,1,2,2],[2,1,2,2,0,2,2,2],[2,1,2,1,2,2,2,1],[2,1,2,1,2,2,1,2],[2,1,2,1,2,1,2,2],[2,1,2,1,1,2,2,2],[2,1,2,0,2,2,2,2],[2,1,1,2,2,2,2,1],[2,1,1,2,2,2,1,2],[2,1,1,2,2,1,2,2],[2,1,1,2,1,2,2,2],[2,1,1,1,2,2,2,2],[2,1,0,2,2,2,2,2],[2,0,2,2,2,2,2,1],[2,0,2,2,2,2,1,2],[2,0,2,2,2,1,2,2],[2,0,2,2,1,2,2,2],[2,0,2,1,2,2,2,2],[2,0,1,2,2,2,2,2],[1,2,2,2,2,2,2,0],[1,2,2,2,2,2,1,1],[1,2,2,2,2,2,0,2],[1,2,2,2,2,1,2,1],[1,2,2,2,2,1,1,2],[1,2,2,2,2,0,2,2],[1,2,2,2,1,2,2,1],[1,2,2,2,1,2,1,2],[1,2,2,2,1,1,2,2],[1,2,2,2,0,2,2,2],[1,2,2,1,2,2,2,1],[1,2,2,1,2,2,1,2],[1,2,2,1,2,1,2,2],[1,2,2,1,1,2,2,2],[1,2,2,0,2,2,2,2],[1,2,1,2,2,2,2,1],[1,2,1,2,2,2,1,2],[1,2,1,2,2,1,2,2],[1,2,1,2,1,2,2,2],[1,2,1,1,2,2,2,2],[1,2,0,2,2,2,2,2],[1,1,2,2,2,2,2,1],[1,1,2,2,2,2,1,2],[1,1,2,2,2,1,2,2],[1,1,2,2,1,2,2,2],[1,1,2,1,2,2,2,2],[1,1,1,2,2,2,2,2],[1,0,2,2,2,2,2,2],[0,2,2,2,2,2,2,1],[0,2,2,2,2,2,1,2],[0,2,2,2,2,1,2,2],[0,2,2,2,1,2,2,2],[0,2,2,1,2,2,2,2],[0,2,1,2,2,2,2,2],[0,1,2,2,2,2,2,2]]], + "(2, 2, 2, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,2,2,2,0],[2,2,2,2,2,2,1,1],[2,2,2,2,2,2,0,2],[2,2,2,2,2,1,2,1],[2,2,2,2,2,1,1,2],[2,2,2,2,2,0,2,2],[2,2,2,2,1,2,2,1],[2,2,2,2,1,2,1,2],[2,2,2,2,1,1,2,2],[2,2,2,2,0,2,2,2],[2,2,2,1,2,2,2,1],[2,2,2,1,2,2,1,2],[2,2,2,1,2,1,2,2],[2,2,2,1,1,2,2,2],[2,2,2,0,2,2,2,2],[2,2,1,2,2,2,2,1],[2,2,1,2,2,2,1,2],[2,2,1,2,2,1,2,2],[2,2,1,2,1,2,2,2],[2,2,1,1,2,2,2,2],[2,2,0,2,2,2,2,2],[2,1,2,2,2,2,2,1],[2,1,2,2,2,2,1,2],[2,1,2,2,2,1,2,2],[2,1,2,2,1,2,2,2],[2,1,2,1,2,2,2,2],[2,1,1,2,2,2,2,2],[2,0,2,2,2,2,2,2],[1,2,2,2,2,2,2,1],[1,2,2,2,2,2,1,2],[1,2,2,2,2,1,2,2],[1,2,2,2,1,2,2,2],[1,2,2,1,2,2,2,2],[1,2,1,2,2,2,2,2],[1,1,2,2,2,2,2,2],[0,2,2,2,2,2,2,2]]] + }, + "SU(9)": { + "(0, 0, 0, 0, 0, 0, 0, 0, 0)": [[1],[[0,0,0,0,0,0,0,0,0]]], + "(1, 0, 0, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1],[[1,0,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,0,1]]], + "(1, 1, 0, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,0,0,0,0,0,0,0],[1,0,1,0,0,0,0,0,0],[1,0,0,1,0,0,0,0,0],[1,0,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0,0],[1,0,0,0,0,0,1,0,0],[1,0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,0,1],[0,1,1,0,0,0,0,0,0],[0,1,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,1,0,0,0,1,0,0,0],[0,1,0,0,0,0,1,0,0],[0,1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,0,1],[0,0,1,1,0,0,0,0,0],[0,0,1,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,1,0,0,0,1,0,0],[0,0,1,0,0,0,0,1,0],[0,0,1,0,0,0,0,0,1],[0,0,0,1,1,0,0,0,0],[0,0,0,1,0,1,0,0,0],[0,0,0,1,0,0,1,0,0],[0,0,0,1,0,0,0,1,0],[0,0,0,1,0,0,0,0,1],[0,0,0,0,1,1,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,1,0,0,1,0],[0,0,0,0,1,0,0,0,1],[0,0,0,0,0,1,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,1,0,0,1],[0,0,0,0,0,0,1,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,1,1]]], + "(1, 1, 1, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,0,0,0,0,0,0],[1,1,0,1,0,0,0,0,0],[1,1,0,0,1,0,0,0,0],[1,1,0,0,0,1,0,0,0],[1,1,0,0,0,0,1,0,0],[1,1,0,0,0,0,0,1,0],[1,1,0,0,0,0,0,0,1],[1,0,1,1,0,0,0,0,0],[1,0,1,0,1,0,0,0,0],[1,0,1,0,0,1,0,0,0],[1,0,1,0,0,0,1,0,0],[1,0,1,0,0,0,0,1,0],[1,0,1,0,0,0,0,0,1],[1,0,0,1,1,0,0,0,0],[1,0,0,1,0,1,0,0,0],[1,0,0,1,0,0,1,0,0],[1,0,0,1,0,0,0,1,0],[1,0,0,1,0,0,0,0,1],[1,0,0,0,1,1,0,0,0],[1,0,0,0,1,0,1,0,0],[1,0,0,0,1,0,0,1,0],[1,0,0,0,1,0,0,0,1],[1,0,0,0,0,1,1,0,0],[1,0,0,0,0,1,0,1,0],[1,0,0,0,0,1,0,0,1],[1,0,0,0,0,0,1,1,0],[1,0,0,0,0,0,1,0,1],[1,0,0,0,0,0,0,1,1],[0,1,1,1,0,0,0,0,0],[0,1,1,0,1,0,0,0,0],[0,1,1,0,0,1,0,0,0],[0,1,1,0,0,0,1,0,0],[0,1,1,0,0,0,0,1,0],[0,1,1,0,0,0,0,0,1],[0,1,0,1,1,0,0,0,0],[0,1,0,1,0,1,0,0,0],[0,1,0,1,0,0,1,0,0],[0,1,0,1,0,0,0,1,0],[0,1,0,1,0,0,0,0,1],[0,1,0,0,1,1,0,0,0],[0,1,0,0,1,0,1,0,0],[0,1,0,0,1,0,0,1,0],[0,1,0,0,1,0,0,0,1],[0,1,0,0,0,1,1,0,0],[0,1,0,0,0,1,0,1,0],[0,1,0,0,0,1,0,0,1],[0,1,0,0,0,0,1,1,0],[0,1,0,0,0,0,1,0,1],[0,1,0,0,0,0,0,1,1],[0,0,1,1,1,0,0,0,0],[0,0,1,1,0,1,0,0,0],[0,0,1,1,0,0,1,0,0],[0,0,1,1,0,0,0,1,0],[0,0,1,1,0,0,0,0,1],[0,0,1,0,1,1,0,0,0],[0,0,1,0,1,0,1,0,0],[0,0,1,0,1,0,0,1,0],[0,0,1,0,1,0,0,0,1],[0,0,1,0,0,1,1,0,0],[0,0,1,0,0,1,0,1,0],[0,0,1,0,0,1,0,0,1],[0,0,1,0,0,0,1,1,0],[0,0,1,0,0,0,1,0,1],[0,0,1,0,0,0,0,1,1],[0,0,0,1,1,1,0,0,0],[0,0,0,1,1,0,1,0,0],[0,0,0,1,1,0,0,1,0],[0,0,0,1,1,0,0,0,1],[0,0,0,1,0,1,1,0,0],[0,0,0,1,0,1,0,1,0],[0,0,0,1,0,1,0,0,1],[0,0,0,1,0,0,1,1,0],[0,0,0,1,0,0,1,0,1],[0,0,0,1,0,0,0,1,1],[0,0,0,0,1,1,1,0,0],[0,0,0,0,1,1,0,1,0],[0,0,0,0,1,1,0,0,1],[0,0,0,0,1,0,1,1,0],[0,0,0,0,1,0,1,0,1],[0,0,0,0,1,0,0,1,1],[0,0,0,0,0,1,1,1,0],[0,0,0,0,0,1,1,0,1],[0,0,0,0,0,1,0,1,1],[0,0,0,0,0,0,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,1,0,0,0],[1,1,1,1,1,0,1,0,0],[1,1,1,1,1,0,0,1,0],[1,1,1,1,1,0,0,0,1],[1,1,1,1,0,1,1,0,0],[1,1,1,1,0,1,0,1,0],[1,1,1,1,0,1,0,0,1],[1,1,1,1,0,0,1,1,0],[1,1,1,1,0,0,1,0,1],[1,1,1,1,0,0,0,1,1],[1,1,1,0,1,1,1,0,0],[1,1,1,0,1,1,0,1,0],[1,1,1,0,1,1,0,0,1],[1,1,1,0,1,0,1,1,0],[1,1,1,0,1,0,1,0,1],[1,1,1,0,1,0,0,1,1],[1,1,1,0,0,1,1,1,0],[1,1,1,0,0,1,1,0,1],[1,1,1,0,0,1,0,1,1],[1,1,1,0,0,0,1,1,1],[1,1,0,1,1,1,1,0,0],[1,1,0,1,1,1,0,1,0],[1,1,0,1,1,1,0,0,1],[1,1,0,1,1,0,1,1,0],[1,1,0,1,1,0,1,0,1],[1,1,0,1,1,0,0,1,1],[1,1,0,1,0,1,1,1,0],[1,1,0,1,0,1,1,0,1],[1,1,0,1,0,1,0,1,1],[1,1,0,1,0,0,1,1,1],[1,1,0,0,1,1,1,1,0],[1,1,0,0,1,1,1,0,1],[1,1,0,0,1,1,0,1,1],[1,1,0,0,1,0,1,1,1],[1,1,0,0,0,1,1,1,1],[1,0,1,1,1,1,1,0,0],[1,0,1,1,1,1,0,1,0],[1,0,1,1,1,1,0,0,1],[1,0,1,1,1,0,1,1,0],[1,0,1,1,1,0,1,0,1],[1,0,1,1,1,0,0,1,1],[1,0,1,1,0,1,1,1,0],[1,0,1,1,0,1,1,0,1],[1,0,1,1,0,1,0,1,1],[1,0,1,1,0,0,1,1,1],[1,0,1,0,1,1,1,1,0],[1,0,1,0,1,1,1,0,1],[1,0,1,0,1,1,0,1,1],[1,0,1,0,1,0,1,1,1],[1,0,1,0,0,1,1,1,1],[1,0,0,1,1,1,1,1,0],[1,0,0,1,1,1,1,0,1],[1,0,0,1,1,1,0,1,1],[1,0,0,1,1,0,1,1,1],[1,0,0,1,0,1,1,1,1],[1,0,0,0,1,1,1,1,1],[0,1,1,1,1,1,1,0,0],[0,1,1,1,1,1,0,1,0],[0,1,1,1,1,1,0,0,1],[0,1,1,1,1,0,1,1,0],[0,1,1,1,1,0,1,0,1],[0,1,1,1,1,0,0,1,1],[0,1,1,1,0,1,1,1,0],[0,1,1,1,0,1,1,0,1],[0,1,1,1,0,1,0,1,1],[0,1,1,1,0,0,1,1,1],[0,1,1,0,1,1,1,1,0],[0,1,1,0,1,1,1,0,1],[0,1,1,0,1,1,0,1,1],[0,1,1,0,1,0,1,1,1],[0,1,1,0,0,1,1,1,1],[0,1,0,1,1,1,1,1,0],[0,1,0,1,1,1,1,0,1],[0,1,0,1,1,1,0,1,1],[0,1,0,1,1,0,1,1,1],[0,1,0,1,0,1,1,1,1],[0,1,0,0,1,1,1,1,1],[0,0,1,1,1,1,1,1,0],[0,0,1,1,1,1,1,0,1],[0,0,1,1,1,1,0,1,1],[0,0,1,1,1,0,1,1,1],[0,0,1,1,0,1,1,1,1],[0,0,1,0,1,1,1,1,1],[0,0,0,1,1,1,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 1, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,1,1,0,0],[1,1,1,1,1,1,0,1,0],[1,1,1,1,1,1,0,0,1],[1,1,1,1,1,0,1,1,0],[1,1,1,1,1,0,1,0,1],[1,1,1,1,1,0,0,1,1],[1,1,1,1,0,1,1,1,0],[1,1,1,1,0,1,1,0,1],[1,1,1,1,0,1,0,1,1],[1,1,1,1,0,0,1,1,1],[1,1,1,0,1,1,1,1,0],[1,1,1,0,1,1,1,0,1],[1,1,1,0,1,1,0,1,1],[1,1,1,0,1,0,1,1,1],[1,1,1,0,0,1,1,1,1],[1,1,0,1,1,1,1,1,0],[1,1,0,1,1,1,1,0,1],[1,1,0,1,1,1,0,1,1],[1,1,0,1,1,0,1,1,1],[1,1,0,1,0,1,1,1,1],[1,1,0,0,1,1,1,1,1],[1,0,1,1,1,1,1,1,0],[1,0,1,1,1,1,1,0,1],[1,0,1,1,1,1,0,1,1],[1,0,1,1,1,0,1,1,1],[1,0,1,1,0,1,1,1,1],[1,0,1,0,1,1,1,1,1],[1,0,0,1,1,1,1,1,1],[0,1,1,1,1,1,1,1,0],[0,1,1,1,1,1,1,0,1],[0,1,1,1,1,1,0,1,1],[0,1,1,1,1,0,1,1,1],[0,1,1,1,0,1,1,1,1],[0,1,1,0,1,1,1,1,1],[0,1,0,1,1,1,1,1,1],[0,0,1,1,1,1,1,1,1]]], + "(1, 1, 1, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1],[[1,1,1,1,1,1,1,1,0],[1,1,1,1,1,1,1,0,1],[1,1,1,1,1,1,0,1,1],[1,1,1,1,1,0,1,1,1],[1,1,1,1,0,1,1,1,1],[1,1,1,0,1,1,1,1,1],[1,1,0,1,1,1,1,1,1],[1,0,1,1,1,1,1,1,1],[0,1,1,1,1,1,1,1,1]]], + "(2, 0, 0, 0, 0, 0, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,0,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,0,0],[1,0,1,0,0,0,0,0,0],[1,0,0,1,0,0,0,0,0],[1,0,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0,0],[1,0,0,0,0,0,1,0,0],[1,0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,0,1],[0,2,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0,0],[0,1,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0,0],[0,1,0,0,0,1,0,0,0],[0,1,0,0,0,0,1,0,0],[0,1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,0,1],[0,0,2,0,0,0,0,0,0],[0,0,1,1,0,0,0,0,0],[0,0,1,0,1,0,0,0,0],[0,0,1,0,0,1,0,0,0],[0,0,1,0,0,0,1,0,0],[0,0,1,0,0,0,0,1,0],[0,0,1,0,0,0,0,0,1],[0,0,0,2,0,0,0,0,0],[0,0,0,1,1,0,0,0,0],[0,0,0,1,0,1,0,0,0],[0,0,0,1,0,0,1,0,0],[0,0,0,1,0,0,0,1,0],[0,0,0,1,0,0,0,0,1],[0,0,0,0,2,0,0,0,0],[0,0,0,0,1,1,0,0,0],[0,0,0,0,1,0,1,0,0],[0,0,0,0,1,0,0,1,0],[0,0,0,0,1,0,0,0,1],[0,0,0,0,0,2,0,0,0],[0,0,0,0,0,1,1,0,0],[0,0,0,0,0,1,0,1,0],[0,0,0,0,0,1,0,0,1],[0,0,0,0,0,0,2,0,0],[0,0,0,0,0,0,1,1,0],[0,0,0,0,0,0,1,0,1],[0,0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,0,2]]], + "(2, 1, 1, 1, 1, 1, 1, 1, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,1,1,1,1,1,1,1,0],[2,1,1,1,1,1,1,0,1],[2,1,1,1,1,1,0,1,1],[2,1,1,1,1,0,1,1,1],[2,1,1,1,0,1,1,1,1],[2,1,1,0,1,1,1,1,1],[2,1,0,1,1,1,1,1,1],[2,0,1,1,1,1,1,1,1],[1,2,1,1,1,1,1,1,0],[1,2,1,1,1,1,1,0,1],[1,2,1,1,1,1,0,1,1],[1,2,1,1,1,0,1,1,1],[1,2,1,1,0,1,1,1,1],[1,2,1,0,1,1,1,1,1],[1,2,0,1,1,1,1,1,1],[1,1,2,1,1,1,1,1,0],[1,1,2,1,1,1,1,0,1],[1,1,2,1,1,1,0,1,1],[1,1,2,1,1,0,1,1,1],[1,1,2,1,0,1,1,1,1],[1,1,2,0,1,1,1,1,1],[1,1,1,2,1,1,1,1,0],[1,1,1,2,1,1,1,0,1],[1,1,1,2,1,1,0,1,1],[1,1,1,2,1,0,1,1,1],[1,1,1,2,0,1,1,1,1],[1,1,1,1,2,1,1,1,0],[1,1,1,1,2,1,1,0,1],[1,1,1,1,2,1,0,1,1],[1,1,1,1,2,0,1,1,1],[1,1,1,1,1,2,1,1,0],[1,1,1,1,1,2,1,0,1],[1,1,1,1,1,2,0,1,1],[1,1,1,1,1,1,2,1,0],[1,1,1,1,1,1,2,0,1],[1,1,1,1,1,1,1,2,0],[1,1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,0,2],[1,1,1,1,1,1,0,2,1],[1,1,1,1,1,1,0,1,2],[1,1,1,1,1,0,2,1,1],[1,1,1,1,1,0,1,2,1],[1,1,1,1,1,0,1,1,2],[1,1,1,1,0,2,1,1,1],[1,1,1,1,0,1,2,1,1],[1,1,1,1,0,1,1,2,1],[1,1,1,1,0,1,1,1,2],[1,1,1,0,2,1,1,1,1],[1,1,1,0,1,2,1,1,1],[1,1,1,0,1,1,2,1,1],[1,1,1,0,1,1,1,2,1],[1,1,1,0,1,1,1,1,2],[1,1,0,2,1,1,1,1,1],[1,1,0,1,2,1,1,1,1],[1,1,0,1,1,2,1,1,1],[1,1,0,1,1,1,2,1,1],[1,1,0,1,1,1,1,2,1],[1,1,0,1,1,1,1,1,2],[1,0,2,1,1,1,1,1,1],[1,0,1,2,1,1,1,1,1],[1,0,1,1,2,1,1,1,1],[1,0,1,1,1,2,1,1,1],[1,0,1,1,1,1,2,1,1],[1,0,1,1,1,1,1,2,1],[1,0,1,1,1,1,1,1,2],[0,2,1,1,1,1,1,1,1],[0,1,2,1,1,1,1,1,1],[0,1,1,2,1,1,1,1,1],[0,1,1,1,2,1,1,1,1],[0,1,1,1,1,2,1,1,1],[0,1,1,1,1,1,2,1,1],[0,1,1,1,1,1,1,2,1],[0,1,1,1,1,1,1,1,2]]], + "(2, 2, 2, 2, 2, 2, 2, 2, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[2,2,2,2,2,2,2,2,0],[2,2,2,2,2,2,2,1,1],[2,2,2,2,2,2,2,0,2],[2,2,2,2,2,2,1,2,1],[2,2,2,2,2,2,1,1,2],[2,2,2,2,2,2,0,2,2],[2,2,2,2,2,1,2,2,1],[2,2,2,2,2,1,2,1,2],[2,2,2,2,2,1,1,2,2],[2,2,2,2,2,0,2,2,2],[2,2,2,2,1,2,2,2,1],[2,2,2,2,1,2,2,1,2],[2,2,2,2,1,2,1,2,2],[2,2,2,2,1,1,2,2,2],[2,2,2,2,0,2,2,2,2],[2,2,2,1,2,2,2,2,1],[2,2,2,1,2,2,2,1,2],[2,2,2,1,2,2,1,2,2],[2,2,2,1,2,1,2,2,2],[2,2,2,1,1,2,2,2,2],[2,2,2,0,2,2,2,2,2],[2,2,1,2,2,2,2,2,1],[2,2,1,2,2,2,2,1,2],[2,2,1,2,2,2,1,2,2],[2,2,1,2,2,1,2,2,2],[2,2,1,2,1,2,2,2,2],[2,2,1,1,2,2,2,2,2],[2,2,0,2,2,2,2,2,2],[2,1,2,2,2,2,2,2,1],[2,1,2,2,2,2,2,1,2],[2,1,2,2,2,2,1,2,2],[2,1,2,2,2,1,2,2,2],[2,1,2,2,1,2,2,2,2],[2,1,2,1,2,2,2,2,2],[2,1,1,2,2,2,2,2,2],[2,0,2,2,2,2,2,2,2],[1,2,2,2,2,2,2,2,1],[1,2,2,2,2,2,2,1,2],[1,2,2,2,2,2,1,2,2],[1,2,2,2,2,1,2,2,2],[1,2,2,2,1,2,2,2,2],[1,2,2,1,2,2,2,2,2],[1,2,1,2,2,2,2,2,2],[1,1,2,2,2,2,2,2,2],[0,2,2,2,2,2,2,2,2]]] } } \ No newline at end of file diff --git a/geometric_kernels/spaces/so.py b/geometric_kernels/spaces/so.py index 1ddb8a64..4edaf222 100644 --- a/geometric_kernels/spaces/so.py +++ b/geometric_kernels/spaces/so.py @@ -65,7 +65,7 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: eig_and_signature = [ (round(4*self._compute_eigenvalue(signature)), signature) - for signature in signatures] + for signature in signatures] eig_and_signature.sort() signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] return signatures diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index 21dc4ef9..ad540bfc 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -47,11 +47,11 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: ) ) signatures = [sgn + (0,) for sgn in signatures] - + eig_and_signature = [ - (round(4 * (len(signature)**2) - * self._compute_eigenvalue(signature)), signature) - for signature in signatures] + (round(4 * (len(signature)**2) + * self._compute_eigenvalue(signature)), signature) + for signature in signatures] eig_and_signature.sort() signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] diff --git a/geometric_kernels/utils/compute_characters.py b/geometric_kernels/utils/compute_characters.py index 0c36ab35..2f56838b 100644 --- a/geometric_kernels/utils/compute_characters.py +++ b/geometric_kernels/utils/compute_characters.py @@ -13,6 +13,7 @@ import itertools import json import sys +from tqdm import tqdm import more_itertools import sympy @@ -312,10 +313,10 @@ def compute_character_formula_su(self, signature): for name, n, eigenfunctions_class in groups: group_name = "{}({})".format(name, n) print(group_name) - eigenfunctions = eigenfunctions_class(order, n, compute_characters=False) + eigenfunctions = eigenfunctions_class(n, order, compute_characters=False) if recalculate or (not recalculate and group_name not in characters): characters[group_name] = {} - for signature in eigenfunctions._signatures: + for signature in tqdm(eigenfunctions._signatures): if str(signature) not in characters[group_name]: sys.stdout.write("{}: ".format(str(signature))) if isinstance(eigenfunctions, SOEigenfunctions): From bd8bfa781e1ed5394a9249541292a3270149c11b Mon Sep 17 00:00:00 2001 From: imbirik Date: Sat, 12 Oct 2024 19:27:00 +0100 Subject: [PATCH 21/24] Fix of linting --- geometric_kernels/spaces/so.py | 6 ++++-- geometric_kernels/spaces/su.py | 7 ++++--- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/geometric_kernels/spaces/so.py b/geometric_kernels/spaces/so.py index 4edaf222..0ed3cfa7 100644 --- a/geometric_kernels/spaces/so.py +++ b/geometric_kernels/spaces/so.py @@ -64,8 +64,10 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: signatures.append(tuple(signature)) eig_and_signature = [ - (round(4*self._compute_eigenvalue(signature)), signature) - for signature in signatures] + (round(4 * self._compute_eigenvalue(signature)), signature) + for signature in signatures + ] + eig_and_signature.sort() signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] return signatures diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index ad540bfc..5163505a 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -49,9 +49,10 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: signatures = [sgn + (0,) for sgn in signatures] eig_and_signature = [ - (round(4 * (len(signature)**2) - * self._compute_eigenvalue(signature)), signature) - for signature in signatures] + (round(4 * (len(signature) ** 2) + * self._compute_eigenvalue(signature)), signature) + for signature in signatures + ] eig_and_signature.sort() signatures = [eig_sgn[1] for eig_sgn in eig_and_signature][:num_levels] From 8e1210c813145905d99589951689dcc19482c381 Mon Sep 17 00:00:00 2001 From: imbirik Date: Sat, 12 Oct 2024 20:04:27 +0100 Subject: [PATCH 22/24] Fix of linting --- geometric_kernels/spaces/su.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/geometric_kernels/spaces/su.py b/geometric_kernels/spaces/su.py index 5163505a..24c872f8 100644 --- a/geometric_kernels/spaces/su.py +++ b/geometric_kernels/spaces/su.py @@ -49,8 +49,10 @@ def _generate_signatures(self, num_levels: int) -> List[Tuple[int, ...]]: signatures = [sgn + (0,) for sgn in signatures] eig_and_signature = [ - (round(4 * (len(signature) ** 2) - * self._compute_eigenvalue(signature)), signature) + ( + round(4 * (len(signature) ** 2) * self._compute_eigenvalue(signature)), + signature, + ) for signature in signatures ] From 34e37a03352b073ced164186e2208b5a65354267 Mon Sep 17 00:00:00 2001 From: imbirik Date: Sat, 12 Oct 2024 20:39:08 +0100 Subject: [PATCH 23/24] fix of linting --- geometric_kernels/utils/compute_characters.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/geometric_kernels/utils/compute_characters.py b/geometric_kernels/utils/compute_characters.py index 2f56838b..49a29a38 100644 --- a/geometric_kernels/utils/compute_characters.py +++ b/geometric_kernels/utils/compute_characters.py @@ -13,12 +13,12 @@ import itertools import json import sys -from tqdm import tqdm import more_itertools import sympy from beartype.typing import Union from sympy.matrices.determinant import _det as sp_det +from tqdm import tqdm from geometric_kernels.spaces.so import SOEigenfunctions from geometric_kernels.spaces.su import SUEigenfunctions # noqa From 0c0db8a113b2e32c55df8962f3d0f4ea847b190e Mon Sep 17 00:00:00 2001 From: imbirik Date: Sat, 12 Oct 2024 20:52:36 +0100 Subject: [PATCH 24/24] compute SU2 --- .../resources/precomputed_characters.json | 27 +++++++++++++++++++ geometric_kernels/utils/compute_characters.py | 1 + 2 files changed, 28 insertions(+) diff --git a/geometric_kernels/resources/precomputed_characters.json b/geometric_kernels/resources/precomputed_characters.json index 62ec78e8..bbe962a5 100644 --- a/geometric_kernels/resources/precomputed_characters.json +++ b/geometric_kernels/resources/precomputed_characters.json @@ -173,6 +173,33 @@ "(2, 1, 1, 1)": [[1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,1,1,1,1,1,2,1,1,1,1,4,1,4,7,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,1,1,2,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,1,1,2,1,1,1,4,7,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,1,1,2,1,2,2,3,1,1,1,2,1,1,1,4,7,1,7,9,1,2,1,7,9,2,9,15,1,2,2,3,1,2,1,7,9,2,9,15,2,3,2,9,15,3,15,20],[[2,1,1,1,0,0,0,0],[2,1,1,0,0,0,0,1],[2,1,1,0,0,0,0,0],[2,1,0,1,0,0,1,0],[2,1,0,1,0,0,0,0],[2,1,0,0,0,0,1,1],[2,1,0,0,0,0,1,0],[2,1,0,0,0,0,0,1],[2,1,0,0,0,0,0,0],[2,0,1,1,0,1,0,0],[2,0,1,1,0,0,0,0],[2,0,1,0,0,1,0,1],[2,0,1,0,0,1,0,0],[2,0,1,0,0,0,0,1],[2,0,1,0,0,0,0,0],[2,0,0,1,0,1,1,0],[2,0,0,1,0,1,0,0],[2,0,0,1,0,0,1,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,1,1],[2,0,0,0,0,1,1,0],[2,0,0,0,0,1,0,1],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,1],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,1,1,0,0,0,0],[1,2,1,0,0,0,0,1],[1,2,1,0,0,0,0,0],[1,2,0,1,0,0,1,0],[1,2,0,1,0,0,0,0],[1,2,0,0,0,0,1,1],[1,2,0,0,0,0,1,0],[1,2,0,0,0,0,0,1],[1,2,0,0,0,0,0,0],[1,1,2,1,0,0,0,0],[1,1,2,0,0,0,0,1],[1,1,2,0,0,0,0,0],[1,1,1,2,0,0,0,0],[1,1,1,1,0,0,0,0],[1,1,1,0,0,0,0,2],[1,1,1,0,0,0,0,1],[1,1,1,0,0,0,0,0],[1,1,0,2,0,0,1,0],[1,1,0,2,0,0,0,0],[1,1,0,1,0,0,2,0],[1,1,0,1,0,0,1,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,2,1],[1,1,0,0,0,0,2,0],[1,1,0,0,0,0,1,2],[1,1,0,0,0,0,1,1],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,2],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,1,0,1,0,0],[1,0,2,1,0,0,0,0],[1,0,2,0,0,1,0,1],[1,0,2,0,0,1,0,0],[1,0,2,0,0,0,0,1],[1,0,2,0,0,0,0,0],[1,0,1,2,0,1,0,0],[1,0,1,2,0,0,0,0],[1,0,1,1,0,2,0,0],[1,0,1,1,0,1,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,2,0,1],[1,0,1,0,0,2,0,0],[1,0,1,0,0,1,0,2],[1,0,1,0,0,1,0,1],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,2],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,1,1,0],[1,0,0,2,0,1,0,0],[1,0,0,2,0,0,1,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,2,1,0],[1,0,0,1,0,2,0,0],[1,0,0,1,0,1,2,0],[1,0,0,1,0,1,1,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,2,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,1,1],[1,0,0,0,0,2,1,0],[1,0,0,0,0,2,0,1],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,2,1],[1,0,0,0,0,1,2,0],[1,0,0,0,0,1,1,2],[1,0,0,0,0,1,1,1],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,2],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,1],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,2],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,2,1,1,1,0,0,0],[0,2,1,1,0,0,0,0],[0,2,1,0,1,0,0,1],[0,2,1,0,1,0,0,0],[0,2,1,0,0,0,0,1],[0,2,1,0,0,0,0,0],[0,2,0,1,1,0,1,0],[0,2,0,1,1,0,0,0],[0,2,0,1,0,0,1,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,1,1],[0,2,0,0,1,0,1,0],[0,2,0,0,1,0,0,1],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,1],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,1,1,0,0,0],[0,1,2,1,0,0,0,0],[0,1,2,0,1,0,0,1],[0,1,2,0,1,0,0,0],[0,1,2,0,0,0,0,1],[0,1,2,0,0,0,0,0],[0,1,1,2,1,0,0,0],[0,1,1,2,0,0,0,0],[0,1,1,1,2,0,0,0],[0,1,1,1,1,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,2,0,0,1],[0,1,1,0,2,0,0,0],[0,1,1,0,1,0,0,2],[0,1,1,0,1,0,0,1],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,2],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,1,0,1,0],[0,1,0,2,1,0,0,0],[0,1,0,2,0,0,1,0],[0,1,0,2,0,0,0,0],[0,1,0,1,2,0,1,0],[0,1,0,1,2,0,0,0],[0,1,0,1,1,0,2,0],[0,1,0,1,1,0,1,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,2,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,1,1],[0,1,0,0,2,0,1,0],[0,1,0,0,2,0,0,1],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,2,1],[0,1,0,0,1,0,2,0],[0,1,0,0,1,0,1,2],[0,1,0,0,1,0,1,1],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,2],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,1],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,2],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,2,1,1,1,0,0],[0,0,2,1,1,0,0,0],[0,0,2,1,0,1,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,1,0,1],[0,0,2,0,1,1,0,0],[0,0,2,0,1,0,0,1],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,1],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,1,1,0,0],[0,0,1,2,1,0,0,0],[0,0,1,2,0,1,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,2,1,0,0],[0,0,1,1,2,0,0,0],[0,0,1,1,1,2,0,0],[0,0,1,1,1,1,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,2,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,1,0,1],[0,0,1,0,2,1,0,0],[0,0,1,0,2,0,0,1],[0,0,1,0,2,0,0,0],[0,0,1,0,1,2,0,1],[0,0,1,0,1,2,0,0],[0,0,1,0,1,1,0,2],[0,0,1,0,1,1,0,1],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,2],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,1],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,2],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,2,1,1,1,0],[0,0,0,2,1,1,0,0],[0,0,0,2,1,0,1,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,1,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,1,1,0],[0,0,0,1,2,1,0,0],[0,0,0,1,2,0,1,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,2,1,0],[0,0,0,1,1,2,0,0],[0,0,0,1,1,1,2,0],[0,0,0,1,1,1,1,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,2,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,1,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,2,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,2,1,1,1],[0,0,0,0,2,1,1,0],[0,0,0,0,2,1,0,1],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,1],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,1,1],[0,0,0,0,1,2,1,0],[0,0,0,0,1,2,0,1],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,2,1],[0,0,0,0,1,1,2,0],[0,0,0,0,1,1,1,2],[0,0,0,0,1,1,1,1],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,2],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,1],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,2],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,2,1,1],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,1],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]], "(3, 0, 0, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,1,1,1,1,4,1,1,1,1,1,4,1,1,4,4],[[3,0,0,0,0,0,0,0],[2,1,0,0,0,0,0,0],[2,0,1,0,0,0,0,0],[2,0,0,1,0,0,0,0],[2,0,0,0,0,1,0,0],[2,0,0,0,0,0,1,0],[2,0,0,0,0,0,0,1],[2,0,0,0,0,0,0,0],[1,2,0,0,0,0,0,0],[1,1,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[1,1,0,0,0,0,1,0],[1,1,0,0,0,0,0,1],[1,1,0,0,0,0,0,0],[1,0,2,0,0,0,0,0],[1,0,1,1,0,0,0,0],[1,0,1,0,0,1,0,0],[1,0,1,0,0,0,0,1],[1,0,1,0,0,0,0,0],[1,0,0,2,0,0,0,0],[1,0,0,1,0,1,0,0],[1,0,0,1,0,0,1,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,2,0,0],[1,0,0,0,0,1,1,0],[1,0,0,0,0,1,0,1],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,2,0],[1,0,0,0,0,0,1,1],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,2],[1,0,0,0,0,0,0,1],[1,0,0,0,0,0,0,0],[0,3,0,0,0,0,0,0],[0,2,1,0,0,0,0,0],[0,2,0,1,0,0,0,0],[0,2,0,0,1,0,0,0],[0,2,0,0,0,0,1,0],[0,2,0,0,0,0,0,1],[0,2,0,0,0,0,0,0],[0,1,2,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,1,0,1,0,0,0],[0,1,1,0,0,0,0,1],[0,1,1,0,0,0,0,0],[0,1,0,2,0,0,0,0],[0,1,0,1,1,0,0,0],[0,1,0,1,0,0,1,0],[0,1,0,1,0,0,0,0],[0,1,0,0,2,0,0,0],[0,1,0,0,1,0,1,0],[0,1,0,0,1,0,0,1],[0,1,0,0,1,0,0,0],[0,1,0,0,0,0,2,0],[0,1,0,0,0,0,1,1],[0,1,0,0,0,0,1,0],[0,1,0,0,0,0,0,2],[0,1,0,0,0,0,0,1],[0,1,0,0,0,0,0,0],[0,0,3,0,0,0,0,0],[0,0,2,1,0,0,0,0],[0,0,2,0,1,0,0,0],[0,0,2,0,0,1,0,0],[0,0,2,0,0,0,0,1],[0,0,2,0,0,0,0,0],[0,0,1,2,0,0,0,0],[0,0,1,1,1,0,0,0],[0,0,1,1,0,1,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,2,0,0,0],[0,0,1,0,1,1,0,0],[0,0,1,0,1,0,0,1],[0,0,1,0,1,0,0,0],[0,0,1,0,0,2,0,0],[0,0,1,0,0,1,0,1],[0,0,1,0,0,1,0,0],[0,0,1,0,0,0,0,2],[0,0,1,0,0,0,0,1],[0,0,1,0,0,0,0,0],[0,0,0,3,0,0,0,0],[0,0,0,2,1,0,0,0],[0,0,0,2,0,1,0,0],[0,0,0,2,0,0,1,0],[0,0,0,2,0,0,0,0],[0,0,0,1,2,0,0,0],[0,0,0,1,1,1,0,0],[0,0,0,1,1,0,1,0],[0,0,0,1,1,0,0,0],[0,0,0,1,0,2,0,0],[0,0,0,1,0,1,1,0],[0,0,0,1,0,1,0,0],[0,0,0,1,0,0,2,0],[0,0,0,1,0,0,1,0],[0,0,0,1,0,0,0,0],[0,0,0,0,3,0,0,0],[0,0,0,0,2,1,0,0],[0,0,0,0,2,0,1,0],[0,0,0,0,2,0,0,1],[0,0,0,0,2,0,0,0],[0,0,0,0,1,2,0,0],[0,0,0,0,1,1,1,0],[0,0,0,0,1,1,0,1],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,2,0],[0,0,0,0,1,0,1,1],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,2],[0,0,0,0,1,0,0,1],[0,0,0,0,1,0,0,0],[0,0,0,0,0,3,0,0],[0,0,0,0,0,2,1,0],[0,0,0,0,0,2,0,1],[0,0,0,0,0,2,0,0],[0,0,0,0,0,1,2,0],[0,0,0,0,0,1,1,1],[0,0,0,0,0,1,1,0],[0,0,0,0,0,1,0,2],[0,0,0,0,0,1,0,1],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,3,0],[0,0,0,0,0,0,2,1],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,1,2],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,3],[0,0,0,0,0,0,0,2],[0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,0]]] }, + "SU(2)": { + "(0, 0)": [[1],[[0,0]]], + "(1, 0)": [[1,1],[[1,0],[0,1]]], + "(10, 0)": [[1,1,1,1,1,1,1,1,1,1,1],[[10,0],[9,1],[8,2],[7,3],[6,4],[5,5],[4,6],[3,7],[2,8],[1,9],[0,10]]], + "(11, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1],[[11,0],[10,1],[9,2],[8,3],[7,4],[6,5],[5,6],[4,7],[3,8],[2,9],[1,10],[0,11]]], + "(12, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1],[[12,0],[11,1],[10,2],[9,3],[8,4],[7,5],[6,6],[5,7],[4,8],[3,9],[2,10],[1,11],[0,12]]], + "(13, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[13,0],[12,1],[11,2],[10,3],[9,4],[8,5],[7,6],[6,7],[5,8],[4,9],[3,10],[2,11],[1,12],[0,13]]], + "(14, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[14,0],[13,1],[12,2],[11,3],[10,4],[9,5],[8,6],[7,7],[6,8],[5,9],[4,10],[3,11],[2,12],[1,13],[0,14]]], + "(15, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[15,0],[14,1],[13,2],[12,3],[11,4],[10,5],[9,6],[8,7],[7,8],[6,9],[5,10],[4,11],[3,12],[2,13],[1,14],[0,15]]], + "(16, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[16,0],[15,1],[14,2],[13,3],[12,4],[11,5],[10,6],[9,7],[8,8],[7,9],[6,10],[5,11],[4,12],[3,13],[2,14],[1,15],[0,16]]], + "(17, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[17,0],[16,1],[15,2],[14,3],[13,4],[12,5],[11,6],[10,7],[9,8],[8,9],[7,10],[6,11],[5,12],[4,13],[3,14],[2,15],[1,16],[0,17]]], + "(18, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[18,0],[17,1],[16,2],[15,3],[14,4],[13,5],[12,6],[11,7],[10,8],[9,9],[8,10],[7,11],[6,12],[5,13],[4,14],[3,15],[2,16],[1,17],[0,18]]], + "(19, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[19,0],[18,1],[17,2],[16,3],[15,4],[14,5],[13,6],[12,7],[11,8],[10,9],[9,10],[8,11],[7,12],[6,13],[5,14],[4,15],[3,16],[2,17],[1,18],[0,19]]], + "(2, 0)": [[1,1,1],[[2,0],[1,1],[0,2]]], + "(20, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[20,0],[19,1],[18,2],[17,3],[16,4],[15,5],[14,6],[13,7],[12,8],[11,9],[10,10],[9,11],[8,12],[7,13],[6,14],[5,15],[4,16],[3,17],[2,18],[1,19],[0,20]]], + "(21, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[21,0],[20,1],[19,2],[18,3],[17,4],[16,5],[15,6],[14,7],[13,8],[12,9],[11,10],[10,11],[9,12],[8,13],[7,14],[6,15],[5,16],[4,17],[3,18],[2,19],[1,20],[0,21]]], + "(22, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[22,0],[21,1],[20,2],[19,3],[18,4],[17,5],[16,6],[15,7],[14,8],[13,9],[12,10],[11,11],[10,12],[9,13],[8,14],[7,15],[6,16],[5,17],[4,18],[3,19],[2,20],[1,21],[0,22]]], + "(23, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[23,0],[22,1],[21,2],[20,3],[19,4],[18,5],[17,6],[16,7],[15,8],[14,9],[13,10],[12,11],[11,12],[10,13],[9,14],[8,15],[7,16],[6,17],[5,18],[4,19],[3,20],[2,21],[1,22],[0,23]]], + "(24, 0)": [[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[[24,0],[23,1],[22,2],[21,3],[20,4],[19,5],[18,6],[17,7],[16,8],[15,9],[14,10],[13,11],[12,12],[11,13],[10,14],[9,15],[8,16],[7,17],[6,18],[5,19],[4,20],[3,21],[2,22],[1,23],[0,24]]], + "(3, 0)": [[1,1,1,1],[[3,0],[2,1],[1,2],[0,3]]], + "(4, 0)": [[1,1,1,1,1],[[4,0],[3,1],[2,2],[1,3],[0,4]]], + "(5, 0)": [[1,1,1,1,1,1],[[5,0],[4,1],[3,2],[2,3],[1,4],[0,5]]], + "(6, 0)": [[1,1,1,1,1,1,1],[[6,0],[5,1],[4,2],[3,3],[2,4],[1,5],[0,6]]], + "(7, 0)": [[1,1,1,1,1,1,1,1],[[7,0],[6,1],[5,2],[4,3],[3,4],[2,5],[1,6],[0,7]]], + "(8, 0)": [[1,1,1,1,1,1,1,1,1],[[8,0],[7,1],[6,2],[5,3],[4,4],[3,5],[2,6],[1,7],[0,8]]], + "(9, 0)": [[1,1,1,1,1,1,1,1,1,1],[[9,0],[8,1],[7,2],[6,3],[5,4],[4,5],[3,6],[2,7],[1,8],[0,9]]] + }, "SU(3)": { "(0, 0, 0)": [[1],[[0,0,0]]], "(1, 0, 0)": [[1,1,1],[[1,0,0],[0,1,0],[0,0,1]]], diff --git a/geometric_kernels/utils/compute_characters.py b/geometric_kernels/utils/compute_characters.py index 49a29a38..9b4d4aa3 100644 --- a/geometric_kernels/utils/compute_characters.py +++ b/geometric_kernels/utils/compute_characters.py @@ -45,6 +45,7 @@ ("SO", 8, SOEigenfunctions), ("SO", 9, SOEigenfunctions), ("SO", 10, SOEigenfunctions), + ("SU", 2, SUEigenfunctions), ("SU", 3, SUEigenfunctions), ("SU", 4, SUEigenfunctions), ("SU", 5, SUEigenfunctions),