bitstring 4.2.2__py3-none-any.whl → 4.2.3__py3-none-any.whl

bitstring/__init__.py

@@ -55,7 +55,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 """
 
-__version__ = "4.2.2"
+__version__ = "4.2.3"
 
 __author__ = "Scott Griffiths"
 
@@ -111,31 +111,38 @@ class _MyModuleType(types.ModuleType):
 
 sys.modules[__name__].__class__ = _MyModuleType
 
-"""These methods convert a bit length to the number of characters needed to print it for different interpretations."""
+
+# These methods convert a bit length to the number of characters needed to print it for different interpretations.
 def hex_bits2chars(bitlength: int):
     # One character for every 4 bits
     return bitlength // 4
 
+
 def oct_bits2chars(bitlength: int):
     # One character for every 3 bits
     return bitlength // 3
 
+
 def bin_bits2chars(bitlength: int):
     # One character for each bit
     return bitlength
 
+
 def bytes_bits2chars(bitlength: int):
     # One character for every 8 bits
     return bitlength // 8
 
+
 def uint_bits2chars(bitlength: int):
     # How many characters is largest possible int of this length?
     return len(str((1 << bitlength) - 1))
 
+
 def int_bits2chars(bitlength: int):
     # How many characters is largest negative int of this length? (To include minus sign).
     return len(str((-1 << (bitlength - 1))))
 
+
 def float_bits2chars(bitlength: Literal[16, 32, 64]):
     # These bit lengths were found by looking at lots of possible values
     if bitlength in [16, 32]:
@@ -143,53 +150,65 @@ def float_bits2chars(bitlength: Literal[16, 32, 64]):
     else:
         return 24  # Empirical value
 
-def p3binary_bits2chars(bitlength: Literal[8]):
+
+def p3binary_bits2chars(_: Literal[8]):
     return 19  # Empirical value
 
-def p4binary_bits2chars(bitlength: Literal[8]):
+
+def p4binary_bits2chars(_: Literal[8]):
     # Found by looking at all the possible values
     return 13  # Empirical value
 
-def e4m3mxfp_bits2chars(bitlength: Literal[8]):
+
+def e4m3mxfp_bits2chars(_: Literal[8]):
     return 13
 
-def e5m2mxfp_bits2chars(bitlength: Literal[8]):
+
+def e5m2mxfp_bits2chars(_: Literal[8]):
     return 19
 
-def e3m2mxfp_bits2chars(bitlength: Literal[6]):
+
+def e3m2mxfp_bits2chars(_: Literal[6]):
     # Not sure what the best value is here. It's 7 without considering the scale that could be applied.
     return 7
 
-def e2m3mxfp_bits2chars(bitlength: Literal[6]):
+
+def e2m3mxfp_bits2chars(_: Literal[6]):
     # Not sure what the best value is here.
     return 7
 
-def e2m1mxfp_bits2chars(bitlength: Literal[4]):
+
+def e2m1mxfp_bits2chars(_: Literal[4]):
     # Not sure what the best value is here.
     return 7
 
-def e8m0mxfp_bits2chars(bitlength: Literal[8]):
-    # Can range same as float32
+
+def e8m0mxfp_bits2chars(_: Literal[8]):
+    # Has same range as float32
     return 23
 
-def mxint_bits2chars(bitlength: Literal[8]):
+
+def mxint_bits2chars(_: Literal[8]):
     # Not sure what the best value is here.
     return 10
 
 
-def bfloat_bits2chars(bitlength: Literal[16]):
+def bfloat_bits2chars(_: Literal[16]):
     # Found by looking at all the possible values
     return 23  # Empirical value
 
+
 def bits_bits2chars(bitlength: int):
     # For bits type we can see how long it needs to be printed by trying any value
     temp = Bits(bitlength)
     return len(str(temp))
 
-def bool_bits2chars(bitlength: Literal[1]):
+
+def bool_bits2chars(_: Literal[1]):
     # Bools are printed as 1 or 0, not True or False, so are one character each
     return 1
 
+
 dtype_definitions = [
     # Integer types
     DtypeDefinition('uint', Bits._setuint, Bits._getuint, int, False, uint_bits2chars,

bitstring/__main__.py

@@ -47,4 +47,4 @@ $ python -m bitstring hex=01, uint:12=352.hex
 
 
 if __name__ == '__main__':
-    main()
+    main()

bitstring/array_.py

@@ -93,6 +93,7 @@ class Array:
             self.data += BitArray._create_from_bitstype(trailing_bits)
 
     _largest_values = None
+
     @staticmethod
     def _calculate_auto_scale(initializer, name: str, length: Optional[int]) -> float:
         # Now need to find the largest power of 2 representable with this format.
@@ -112,12 +113,15 @@ class Array:
             }
         if f'{name}{length}' in Array._largest_values.keys():
             float_values = Array('float64', initializer).tolist()
+            if not float_values:
+                raise ValueError("Can't calculate an 'auto' scale with an empty Array initializer.")
             max_float_value = max(abs(x) for x in float_values)
             if max_float_value == 0:
                 # This special case isn't covered in the standard. I'm choosing to return no scale.
                 return 1.0
-            log2 = int(math.log2(max_float_value))
-            lp2 = int(math.log2(Array._largest_values[f'{name}{length}']))
+            # We need to find the largest power of 2 that is less than the max value
+            log2 = math.floor(math.log2(max_float_value))
+            lp2 = math.floor(math.log2(Array._largest_values[f'{name}{length}']))
             lg_scale = log2 - lp2
             # Saturate at values representable in E8M0 format.
             if lg_scale > 127:
@@ -155,7 +159,7 @@ class Array:
             except ValueError:
                 name_length = utils.parse_single_struct_token(new_dtype)
                 if name_length is not None:
-                    dtype = Dtype(*name_length)
+                    dtype = Dtype(name_length[0], name_length[1])
                 else:
                     raise ValueError(f"Inappropriate Dtype for Array: '{new_dtype}'.")
             if dtype.length is None:
@@ -270,7 +274,7 @@ class Array:
         return new_array
 
     def tolist(self) -> List[ElementType]:
-        return  [self._dtype.read_fn(self.data, start=start)
+        return [self._dtype.read_fn(self.data, start=start)
                 for start in range(0, len(self.data) - self._dtype.length + 1, self._dtype.length)]
 
     def append(self, x: ElementType) -> None:
@@ -408,9 +412,11 @@ class Array:
             token_list = utils.preprocess_tokens(fmt)
             if len(token_list) not in [1, 2]:
                 raise ValueError(f"Only one or two tokens can be used in an Array.pp() format - '{fmt}' has {len(token_list)} tokens.")
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
+            name1, length1 = utils.parse_name_length_token(token_list[0])
+            dtype1 = Dtype(name1, length1)
             if len(token_list) == 2:
-                dtype2 = Dtype(*utils.parse_name_length_token(token_list[1]))
+                name2, length2 = utils.parse_name_length_token(token_list[1])
+                dtype2 = Dtype(name2, length2)
 
         token_length = dtype1.bitlength
         if dtype2 is not None:

bitstring/bitarray_.py

@@ -11,6 +11,7 @@ from bitstring.bits import Bits, BitsType, TBits
 
 import bitstring.dtypes
 
+
 class BitArray(Bits):
     """A container holding a mutable sequence of bits.
 
@@ -71,7 +72,6 @@ class BitArray(Bits):
     # As BitArray objects are mutable, we shouldn't allow them to be hashed.
     __hash__: None = None
 
-
     def __init__(self, auto: Optional[Union[BitsType, int]] = None, /, length: Optional[int] = None,
                  offset: Optional[int] = None, **kwargs) -> None:
         """Either specify an 'auto' initialiser:
@@ -172,6 +172,7 @@ class BitArray(Bits):
 
     def _setitem_slice(self, key: slice, value: BitsType) -> None:
         if isinstance(value, numbers.Integral):
+            value = int(value)
             if key.step not in [None, -1, 1]:
                 if value in [0, 1]:
                     self.set(value, range(*key.indices(len(self))))
@@ -195,7 +196,7 @@ class BitArray(Bits):
 
     def __setitem__(self, key: Union[slice, int], value: BitsType) -> None:
         if isinstance(key, numbers.Integral):
-            self._setitem_int(key, value)
+            self._setitem_int(int(key), value)
         else:
             self._setitem_slice(key, value)
 
@@ -573,5 +574,3 @@ class BitArray(Bits):
     def clear(self) -> None:
         """Remove all bits, reset to zero length."""
         self._clear()
-
-

bitstring/bits.py

@@ -1699,34 +1699,37 @@ class Bits:
 
     @staticmethod
     def _process_pp_tokens(token_list, fmt):
+        if len(token_list) not in [1, 2]:
+            raise ValueError(
+                f"Only one or two tokens can be used in an pp() format - '{fmt}' has {len(token_list)} tokens.")
         has_length_in_fmt = True
-        if len(token_list) == 1:
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
-            dtype2 = None
-            bits_per_group = dtype1.bitlength
+        name1, length1 = utils.parse_name_length_token(token_list[0])
+        dtype1 = Dtype(name1, length1)
+        bits_per_group = dtype1.bitlength
+        dtype2 = None
+
+        if len(token_list) == 2:
+            name2, length2 = utils.parse_name_length_token(token_list[1])
+            dtype2 = Dtype(name2, length2)
+            if None not in {dtype1.bitlength, dtype2.bitlength} and dtype1.bitlength != dtype2.bitlength:
+                raise ValueError(
+                    f"Differing bit lengths of {dtype1.bitlength} and {dtype2.bitlength} in format string '{fmt}'.")
             if bits_per_group is None:
-                has_length_in_fmt = False
+                bits_per_group = dtype2.bitlength
+
+        if bits_per_group is None:
+            has_length_in_fmt = False
+            if len(token_list) == 1:
                 bits_per_group = {'bin': 8, 'hex': 8, 'oct': 12, 'bytes': 32}.get(dtype1.name)
                 if bits_per_group is None:
                     raise ValueError(f"No length or default length available for pp() format '{fmt}'.")
-        elif len(token_list) == 2:
-            dtype1 = Dtype(*utils.parse_name_length_token(token_list[0]))
-            dtype2 = Dtype(*utils.parse_name_length_token(token_list[1]))
-            if dtype1.bitlength is not None and dtype2.bitlength is not None and dtype1.bitlength != dtype2.bitlength:
-                raise ValueError(
-                    f"Differing bit lengths of {dtype1.bitlength} and {dtype2.bitlength} in format string '{fmt}'.")
-            bits_per_group = dtype1.bitlength if dtype1.bitlength is not None else dtype2.bitlength
-            if bits_per_group is None:
-                has_length_in_fmt = False
+            else:
                 try:
                     bits_per_group = 2 * Bits._bits_per_char(dtype1.name) * Bits._bits_per_char(dtype2.name)
                 except ValueError:
                     raise ValueError(f"Can't find a default bitlength to use for pp() format '{fmt}'.")
                 if bits_per_group >= 24:
                     bits_per_group //= 2
-        else:
-            raise ValueError(
-                f"Only one or two tokens can be used in an pp() format - '{fmt}' has {len(token_list)} tokens.")
         return dtype1, dtype2, bits_per_group, has_length_in_fmt
 
     def pp(self, fmt: Optional[str] = None, width: int = 120, sep: str = ' ',

bitstring/bitstore.py

@@ -14,7 +14,8 @@ def offset_slice_indices_lsb0(key: slice, length: int) -> slice:
     # For negative step we sometimes get a negative stop, which can't be used correctly in a new slice
     return slice(new_start, None if new_stop < 0 else new_stop, step)
 
-def offset_start_stop_lsb0(start: Optional[int], stop: Optional[int], length: int) -> slice:
+
+def offset_start_stop_lsb0(start: Optional[int], stop: Optional[int], length: int) -> tuple[int, int]:
     # First convert slice to all integers
     # Length already should take account of the offset
     start, stop, _ = slice(start, stop, None).indices(length)
@@ -218,7 +219,6 @@ class BitStore:
     def getindex_lsb0(self, index: int, /) -> bool:
         return bool(self._bitarray.__getitem__(-index - 1))
 
-
     @overload
     def setitem_lsb0(self, key: int, value: int, /) -> None:
         ...
@@ -269,4 +269,4 @@ class BitStore:
             self._bitarray.__setitem__(key, value)
 
     def delitem_msb0(self, key, /):
-        self._bitarray.__delitem__(key)
+        self._bitarray.__delitem__(key)

bitstring/bitstore_helpers.py

@@ -8,7 +8,8 @@ import bitarray
 from bitstring.bitstore import BitStore
 import bitstring
 from bitstring.fp8 import p4binary_fmt, p3binary_fmt
-from bitstring.mxfp import e3m2mxfp_fmt, e2m3mxfp_fmt, e2m1mxfp_fmt, e4m3mxfp_saturate_fmt, e5m2mxfp_saturate_fmt, e4m3mxfp_overflow_fmt, e5m2mxfp_overflow_fmt
+from bitstring.mxfp import (e3m2mxfp_fmt, e2m3mxfp_fmt, e2m1mxfp_fmt, e4m3mxfp_saturate_fmt,
+                            e5m2mxfp_saturate_fmt, e4m3mxfp_overflow_fmt, e5m2mxfp_overflow_fmt)
 
 # The size of various caches used to improve performance
 CACHE_SIZE = 256
@@ -121,11 +122,13 @@ def p4binary2bitstore(f: Union[str, float]) -> BitStore:
     u = p4binary_fmt.float_to_int8(f)
     return int2bitstore(u, 8, False)
 
+
 def p3binary2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     u = p3binary_fmt.float_to_int8(f)
     return int2bitstore(u, 8, False)
 
+
 def e4m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if bitstring.options.mxfp_overflow == 'saturate':
@@ -134,6 +137,7 @@ def e4m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
         u = e4m3mxfp_overflow_fmt.float_to_int(f)
     return int2bitstore(u, 8, False)
 
+
 def e5m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if bitstring.options.mxfp_overflow == 'saturate':
@@ -142,6 +146,7 @@ def e5m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
         u = e5m2mxfp_overflow_fmt.float_to_int(f)
     return int2bitstore(u, 8, False)
 
+
 def e3m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -149,6 +154,7 @@ def e3m2mxfp2bitstore(f: Union[str, float]) -> BitStore:
     u = e3m2mxfp_fmt.float_to_int(f)
     return int2bitstore(u, 6, False)
 
+
 def e2m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -156,6 +162,7 @@ def e2m3mxfp2bitstore(f: Union[str, float]) -> BitStore:
     u = e2m3mxfp_fmt.float_to_int(f)
     return int2bitstore(u, 6, False)
 
+
 def e2m1mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -165,6 +172,8 @@ def e2m1mxfp2bitstore(f: Union[str, float]) -> BitStore:
 
 
 e8m0mxfp_allowed_values = [float(2 ** x) for x in range(-127, 128)]
+
+
 def e8m0mxfp2bitstore(f: Union[str, float]) -> BitStore:
     f = float(f)
     if math.isnan(f):
@@ -199,6 +208,7 @@ def mxint2bitstore(f: Union[str, float]) -> BitStore:
             i += 1
     return int2bitstore(i, 8, True)
 
+
 def int2bitstore(i: int, length: int, signed: bool) -> BitStore:
     i = int(i)
     try:

bitstring/bitstream.py

@@ -57,7 +57,7 @@ class ConstBitStream(Bits):
     pos -- The current bit position in the bitstring.
     """
 
-    __slots__ = ('_pos')
+    __slots__ = ('_pos',)
 
     def __init__(self, auto: Optional[Union[BitsType, int]] = None, /, length: Optional[int] = None,
                  offset: Optional[int] = None, pos: int = 0, **kwargs) -> None:

bitstring/bitstring_options.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import bitstring
 import os
 
+
 class Options:
     """Internal class to create singleton module options instance."""
 
@@ -91,4 +92,4 @@ class Colour:
             cls.off = '\033[0m'
         else:
             cls.blue = cls.purple = cls.green = cls.off = ''
-        return x
+        return x

bitstring/dtypes.py

@@ -55,7 +55,6 @@ class Dtype:
     _length: Optional[int]
     _scale: Union[None, float, int]
 
-
     def __new__(cls, token: Union[str, Dtype], /, length: Optional[int] = None, scale: Union[None, float, int] = None) -> Dtype:
         if isinstance(token, cls):
             return token
@@ -253,7 +252,7 @@ class DtypeDefinition:
     """Represents a class of dtypes, such as uint or float, rather than a concrete dtype such as uint8.
     Not (yet) part of the public interface."""
 
-    def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed: bool = False, bitlength2chars_fn = None,
+    def __init__(self, name: str, set_fn, get_fn, return_type: Any = Any, is_signed: bool = False, bitlength2chars_fn=None,
                  variable_length: bool = False, allowed_lengths: Tuple[int, ...] = tuple(), multiplier: int = 1, description: str = ''):
 
         # Consistency checks
@@ -277,7 +276,7 @@ class DtypeDefinition:
         self.set_fn_needs_length = set_fn is not None and 'length' in inspect.signature(set_fn).parameters
         self.set_fn = set_fn
 
-        if self.allowed_lengths:
+        if self.allowed_lengths.values:
             def allowed_length_checked_get_fn(bs):
                 if len(bs) not in self.allowed_lengths:
                     if self.allowed_lengths.only_one_value():
@@ -401,4 +400,4 @@ class Register:
 
 
 # Create the Register singleton
-dtype_register = Register()
+dtype_register = Register()

bitstring/exceptions.py

@@ -21,4 +21,3 @@ class ByteAlignError(Error):
 
 CreationError = ValueError
 """Inappropriate argument during bitstring creation."""
-

bitstring/luts.py

@@ -5,56 +5,57 @@
 mxfp_luts_compressed = \
 {(2, 1, 1, 'saturate'): (b'x\x01\x1d\xc9\xc1\r\xc00\x00\xc2@o\xd6\x8c\xc6f\xf5h\xb1\x828\xf1\x00^>X\x0c\xa7f1,\x7f'
                          b'\x13\x83\xfdY\xf4\x027\xf1\x0c\xfb',
-                         b'x\x01\xed\xdd\t\r\xc0\x00\x08\x04A\xfa\xa7\xbf\x7f\xb5\xad\r\x92\x9bU\x00#\x00\xaaD\x80\x00'
-                         b'\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
-                         b'\x80@[\x81A\x04\x08\x10 \x90(0\x8a@\xb2\xc0\xa4d\x81Y\xd9\x02\x8b\x92\x05Ve\x0bl"@\x80'
+                         b"x\x01\xed\xdd\t\r\xc00\x10\x03\xc1\xf4\xff[\xfehS\x1a'y\x96\x81\x87\x80[\x13\x01\x02"
+                         b'\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80'
                          b'\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
+                         b' @\x80\x00\x01\x02e\x05\x06\x11 @\x80@\xa2\xc0(\x02\xc9\x02\x93\x92\x05fe\x0b,J\x16X\x95-'
+                         b'\xb0\x89\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04'
+                         b'\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00'
+                         b'\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x14\x14\xe8"@ U`\x17\x01\x02\x04\x08\x10 '
+                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
+                         b'\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02u\x05\x0e\x11 @'
+                         b'\x80@\xa2\xc0)\x02\xc9\x02\x97\x92\x05ne\x0b<J\x16x\x95-\xf0\x89\x00\x01\x02\x04\x08\x10'
                          b' @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\r\x05>\x11 \x90*\xd0\xf6.\x99\xc1\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
-                         b' @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10\xa8\xdaE\x80\x00\x01\x02'
-                         b'\x89\x02\x87\x08$\x0b\x9cJ\x16\xb8\x94-p+Y\xe0Q\xb6\xc0+\x02\x04\x08\x10 @\x80\x00'
-                         b'\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
                          b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04'
-                         b'\x08\x10 \xd0P \xf5\xf1\xb9\xbd\t\x10\xf8~uJ\x98\xcc'),
+                         b'\x08\x14\x14H=>\xb7\x9b\x00\x81\xfe\x03\\M8\xf2'),
  (2, 3, 1, 'saturate'): (b'x\x01\x1d\xcdQ\r\xc30\x10\x03\xd0\x830\x08\x85P\x04[ \x14B \x0cB \x04B \x14\xc1v\x10'
                          b'\x02!\x10\x02aO\xb3\xf4\xe4?;\xe2\x9fgD#\x89W\xc4A\xa1\xd2\xe8\x0cn\x92\xc9b\x13%\xe2\xc1'
                          b'\xc1I\xe1\xa2\xf2\xa6\xd1\x19\xdc$\x93\xc5&\x1a\x1fE\x12_[\x14*\x8d\xce\xe0&\x99,6\x91\xfe98'
                          b')\\T\xde4:\x83\x9bd\xb2\xd8\xf9\x03~S=\xdd',
-                         b'x\x01\xed\xdd\x85q\x03\x01\x0cE\xc1\x0b8\xcc\xcc\x9e0sb;\xdc\x7fUN\x15\x9e?7\xdaW\x81\xb4'
-                         b'\x05HM#\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
-                         b'\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04Z#0&\x02'
-                         b'\x04\x08\x10\xa8(0.\x02\x95\x05&TY`RY\x81N\xed\xa6\xaa7]\xbb\x99\xb67\x9bm.\xdd|'
-                         b'\xb6\x85t\x8b\xd9\x96\xd2-g[I\xb7\x9am-\xddz\xb6\x8dt\x9b\xd9\xb6\xd2mg\xdbI\xb7\x9bm/'
-                         b'\xdd~\xb6\x83t\x87\xd9\x8e\xd2uE\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
-                         b'\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x81\x11\t\x0cE\x80@U\x81\xd6\xdc)5(\x01\x02\x04'
-                         b'\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00'
-                         b'\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02Ms,\x02\x04\x08\x10\xa8'
-                         b'(p"\x02\x95\x05NUY\xe0LY\x81\xf3\xda]T\xef\xb2vWm\xef:\xdbM\xba\xdblw\xe9\xee\xb3=\xa4{'
-                         b'\xcc\xf6\x94\xee9\xdbK\xba\xd7lo\xe9\xde\xb3\xf5\xd2\xf5\xb3\r\xd2}d\xfbL\xf7\x95\xed;'
-                         b'\xddO\xb6\xdft\x7f"@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00'
-                         b'\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\xc0\x88\x04\xaa>>\xb77\x01\x02\xc3\x7f3K\xcb\x81'),
+                         b'x\x01\xed\xdd\x85qB\x01\x14DQ\x12\x88\x11#\xeeF\x84\xb8\xbb\xf6_\x15\xa9\x82\xd9\xf9\xf3'
+                         b'\xce\xed`O\x03\xdbj\x89\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01'
+                         b'\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
+                         b'\x80\x00\x81\xc6\x08\x8c\x89\x00\x01\x02\x04*\n\x8c\x8b@e\x81\xb6*\x0bt\x94\x15\x98\xa8\xddd'
+                         b'\xf5\xa6j7\xdd\xf4f\xb2u\xd3\xcdf\x9bK7\x9fm!\xddb\xb6^\xba\xa5l\xcb\xe9V\xb2\xad\xa6['
+                         b'\xcb\xb6\x9en#\xdbf\xba\xadl\xdb\xe9v\xb2\xed\xa6\xdb\xcb\xb6\x9f\xee@\x04\x08\x10 @\x80'
+                         b'\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
+                         b' @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02'
+                         b'\x04\x08\x10\x18\x91\xc0P\x04\x08T\x158\x14\x01\x02\x04\x08\x10 @\x80\x00\x01\x02'
+                         b'\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80'
+                         b'\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\xcd\x118\x12\x01\x02\x04\x08T\x14\xe8\x8b@e\x81c'
+                         b'U\x168QV\xe0\xb4vg\xd5\x1b\xd4\xee\xbc\xe9]d\xbbLw\x95\xed:\xddM\xb6\xdbtw\xd9\xee\xd3=d{L'
+                         b'\xf7\x94\xed9\xddK\xb6\xd7to\xd9\xde\xd3}d\xfbL\xf7\x95\xed;\xddO\xb6\xdft\x7f"@\x80\x00\x01'
+                         b'\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
+                         b'\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08'
+                         b'\x10 @\x80\xc0\x88\x04\xaa\x1e\x9f\xdbM\x80\xc0\xf0\x1f\x9f\x0cK\xfb'),
  (3, 2, 3, 'saturate'): (b'x\x01\x15\xcbA\x15BQ\x08\x05@\xa2XD\xc5&/\nQ(\xa2\xf2\x9b\x10\xc5\x91\xc3\xc0\xe2B\xc4\xbf'
                          b'\xean<"\x92\xa2\x19\x96xF\xdcH\x0eE3,\x91r\x92C\xd1\x0cK\xbc\xe4$\x87\xa2\x19\x96(\xfd'
                          b'\xb6?n(\x9aa\x89\xaf\x7f\x92C\xd1\x0cK\x8c\x9c\xe4P4\xc3\x12\x97\x9c\xe4P4\xc3^?\xc7\x8a;c',
-                         b"x\x01\xed\xdd\xd7Q\x15\x00\x10@\xd1'H\x16D\xa2H\x1a\t\x92\xa3\xe4\xa0\xfdW\xf5h\x81"
-                         b'?\x86\xb9\xe7V\xb0{\n\xd8\x1d\x0cD\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
-                         b' @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08|:'
-                         b'\x81/"@\x80\x00\x81\xa2\xc0\x88\x08\x94\x05FU\x16\xf8\xaa\x8f\x15\x18k7^o\xa2\xddd'
-                         b'\xbd\xa9v\xd3\xf5f\xda}\xab7\xdbn\xae\xde\xf7v\xf3\xf5~\xb4[\xa8\xb7\xd8n\xa9\xder'
-                         b'\xbb\x95z\xab\xed~\xd6[k\xf7\xab\xdez\xbb\x8dz\x9b\xed\xb6\xeam\x8b\x00\x01\x02\x04\x08\x10'
+                         b'x\x01\xed\xdd\xd7U\x15\x00\x00\x04Q$\x89HV@r\x90 Q\xb2\x92\xfb\xaf\xea\xd1\x02\x7f'
+                         b'\x1c\xce\xdc\xe9`o\x03;4$\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01'
+                         b'\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\xe0\xd3\t|'
+                         b'\x11\x01\x02\x04\x08\x14\x05\x86E\xa0,0\xa2\xb2\xc0\xa8>V`\xac\xddx\xbd\xaf\xed&\xea}k7Y\xef'
+                         b'{\xbb\xa9z\xd3\xedf\xea\xcd\xb6\x9b\xab7\xdfn\xa1\xde\x8fv?\xeb-\xb6[\xaa\xb7\xdc\xee'
+                         b'W\xbd\x95v\xab\xf5\xd6\xda\xad\xd7\xdbh\xb7YoK\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
                          b' @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 '
-                         b'@\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\xde%0\x14\x01\x02U\x81Ow\xaf\xd8\xc0'
-                         b'\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80'
-                         b'\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\xc0`\xf0[\x04\x08\x10 P\x14'
-                         b'\xd8\x11\x81\xb2\xc0\xae\xca\x02{\xfaX\x81\xfdv\x7f\xea\x1d\xb4;\xacw\xd4\xee\xb8'
-                         b'\xdeI\xbb\xd3zg\xed\xce\xeb]\xb4\xbb\xacw\xd5\xee\xba\xde\xdfv7\xf5n\xdb\xdd\xd5\xbbo'
-                         b'\xf7P\xef\xb1\xddS\xbd\xe7v/\xf5^\xdb\xfd\xab\xf7_\x04\x08\x10 @\x80\x00\x01\x02\x04\x08'
-                         b'\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01'
-                         b'\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 \xf0.\x81\xea\xe3s{\x13 0|\x03\xb3O;\x10'),
+                         b'@\x80\x00\x01\x02\x04\x08\x10 \xf0.\x81\x81\x08\x10\xa8\nl\x8b\x00\x01\x02\x04\x08\x10 @\x80'
+                         b'\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10'
+                         b' @\x80\x00\x01\x02\x04\x08\x10\xf8|\x02;"@\x80\x00\x81\xa2\xc0\xae\x08\x94\x05~\xab,\xb0'
+                         b'\xa7\x8f\x15\xd8owP\xef\xb0\xdd\x9fzG\xed\x8e\xeb\x9d\xb4;\xadw\xd6\xee\xbc\xde\xdfv\x17'
+                         b'\xf5.\xdb]\xd5\xbbnwS\xef\xb6\xdd]\xbd\x7f\xed\xfe\xd7\xbbo\xf7P\xef\xb1\xddS\xbd\xe7v/\xf5^'
+                         b'E\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @'
+                         b'\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\x04\x08\x10 @\x80\x00\x01\x02\xef\x12'
+                         b'\xa8\x1e\x9f\xdbM\x80\xc0\xe0\r\xd9\xf2;{'),
  (4, 3, 7, 'saturate'): (b'x\x01\x1d\xcd[\xb5\x90!\x10\x80Q"\x18\x81\x08\xbc{C-@\x04"\xd0\xe0\x10\x81\x08D\xe0\xdd\x1bj'
                          b'\x01"\x10\xe1o\xa0\xfb\xc8Z{\xcd\xbc|C\x08\xff\xdf\xdb\x10:\x9b\xf0.\x84H\xa6\xd2\x19'
                          b'L\x16\x9b\xc3\xe5!\xbc\x0f\xe1\r\x91D\xa6Pit\x06\x93\xc5\xe6py\x08\x1f\xf4D\x12\x99'
@@ -65,33 +66,32 @@ mxfp_luts_compressed = \
                          b"\x87\xcbC\xf8\xa9'\x92\xc8\x14*\x8d\xce`\xb2\xd8\x1c.\x0fa\xeb\x89$2\x85J\xa33\x98,6\x87\xcb"
                          b'C\xf8\xa5\'\x92\xc8\x14*\x8d\xce`\xb2\xd8\x1c.\x0f\xe1\xb7\x9eH"S\xa84:\x83\xc9bs\xb8<\x84'
                          b'?z"\x89L\xa1\xd2\xe8\x0c&\x8b\xcd\xe1\xbe\xee\x7f\xff\x01!\xba\xf7\x9b',
-                         b'x\x01\xed\xdde\xb6\x96\x05\x00E\xe1\x0f\x01iD\xba\x11\xe9\x90n\x90\x12\xa4\xbb\xbb[\xbaA'
-                         b'X\x8bF\xa5\x94\x94\xee\xee.iP:\x94\x96FA\xe9N\xbd\xfc`\x10{]\xde\xfd\xcc\xe0\xec\t\x9cP'
-                         b'H\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\xc0\x07['
-                         b' \x82,`\x01\x0bX \x88\x05>\x92\x05\x82\\ \xa2\x82\\ \x92\xd8\x02\x91\x83\xed\xe3\xa0'
-                         b'\x8b\x12lQ\xc3\xbbh\xac\xe8\xb4\x18\xac\x98\xb4X\xac\xd8\xb4OXqh\x9f\xb2\xe2\xd2\xe2\xb1'
-                         b'\xe2\xd3\x12\xb0\x12\xd2\x12\xb1\x12\xd3\x92\xb0\x92\xd2\x92\xb1\x92\xd3R\xb0R\xd2R\xb1'
-                         b'>\xa3\xa5f}NK\xc3JKK\xc7JO\xcb\xc0\xcaH\xcb\xc4\xcaL\xcb\xc2\xcaJ\xfb\x82\x95\x8d\x96\x9d'
-                         b'\x95\x83\x96\x93\x95\x8b\x96\x9b\x95\x87\x96\x97\x95\x8f\x96\x9fU\x80V\x90U\x88V\x98'
-                         b'U\x84\xf6%\xab(\xad\x18\xab8\xad\x04\xab$\xed+V)Zi\xd6\xd7\xb42\xac\xb2\xb4r\xac\xf2\xb4\n'
-                         b'\xac\x8a\xb4J\xac\xca\xb4*\xac\xaa\xb4j\xac\xea\xb4\x1a\xac\x9a\xb4Z\xac\xda\xb4:'
-                         b'\xac\xba\xb4z\xac\xfa\xb4\x06\xac\x86\xb4F\xac\xc6\xb4&\xac\xa6\xb4f\xac\xe6\xb4\x16'
-                         b'\xac\x96\xb4V\xac\xd6\xb46\xac\xb6\xb4v\xac\xf6\xb4\x0e\xacoh\x1dY\x9dh\x9dY]h]Y\xddh\xdd'
-                         b'Y=h=Y\xbdh\xbdY}h}Y\xfdh\xfdY\xdf\xd2\x06\xb0\x06\xca\x02\x16\xb0\x80\x05,`\x01\x0b'
-                         b'X\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80'
-                         b'\x05\xde\x17\x08\x93\x05,\x10\xd4\x02\x1f\xec\xaf\x99\xc3,`\x01\x0bX\xc0\x02\x16\xb0'
-                         b'\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x81Ph\x90,`\x01\x0bX \x88\x05\x06\xcb\x02A.'
-                         b'0DA.0Tl\x81a\xc16<\xe8F\x04\xdb\xc8\xf0\xee;\xd6\xf7\xb4\x1fX\xa3h\xa3YchcY\xe3h?'
-                         b'\xb2~\xa2\x8dgM\xa0MdM\xa2MfM\xa1\xfd\xcc\x9aJ\x9b\xc6\x9aN\x9b\xc1\x9aI\x9b\xc5\x9aM\x9b'
-                         b'\xc3\x9aK\x9b\xc7\x9aO[\xc0ZH[\xc4ZL[\xc2ZJ[\xc6ZN[\xc1ZI[\xc5ZM[\xc3ZK[\xc7ZO\xdb'
-                         b'\xc0\xdaH\xdb\xc4\xdaL\xdb\xc2\xdaJ\xdb\xc6\xdaN\xfb\x85\xb5\x83\xb6\x93\xb5\x8b\xb6'
-                         b'\x9b\xb5\x87\xb6\x97\xb5\x8f\xb6\x9fu\x80\xf6+\xeb7\xdaA\xd6!\xdaa\xd6\x11\xdaQ\xd61\xda'
-                         b'q\xd6\t\xdaI\xd6)\xda\xef\xac?h\xa7YghgY\xe7h\xe7Y\x17h\x17Y\x7f\xd2.\xb1.\xd3'
-                         b'\xae\xb0\xae\xd2\xae\xb1\xae\xd3n\xb0n\xd2\xfeb\xfdM\xbb\xc5\xbaM\xfb\x87\xf5/\xed\x0e\xeb.'
-                         b'\xed\x1e\xeb>\xed\x01\xeb!\xed\x11\xeb1\xed\t\xeb)\xed\x19\xeb9\xed\x05\xeb%\xed\x15\xeb5'
-                         b'\xed\r\xeb-\xed?\xd6\xff\xb2\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0'
-                         b'\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x81\xf7\x05\x82z|\xeen\x0bX'
-                         b' \xec\x1d\xdd\xb0\xc7z'),
+                         b'x\x01\xed\xdd\xd5\x96\x90\x05\x00E\xe1\x01\xe9\x90n\x90\x96F\xbaE\xa4S@\xba\x15\xa4\xbbKX H*'
+                         b'\xdd)\xa9\x12Jw*H\x08Jww\x87\xd25\\\xccC\xec5\xf3\xef\xef\r\xce~\x81\x13\x12"\x0bX'
+                         b'\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX \xc2\x16\x88$\x0b'
+                         b'X\xc0\x02\x16\x08b\x81\xc8\xb2@\x90\x0b|\xa0 \x17\x88"\xb6@\xd4`\x8b\x16t\xd1\x83-Fx\x17\x93'
+                         b'\x15\x8b\x16\x9b\x15\x87\x16\x97\xf5!-\x1e+>-\x01+!-\x11+1-\t+)-\x19+9-\x05+%-\x15+5-\r'
+                         b'\xeb#ZZV:ZzV\x06ZFV&Zf\xd6\xc7\xb4,\xac\xac\xb4l\xac\xec\xb4\x1c\xac\x9c\xb4\\\xac\xdc\xb4O'
+                         b'XyhyY\xf9h\xf9Y\x05h\x05Y\x85h\x85YEhEY\xc5h\xc5Y%h\x9f\xb2J\xd2>c\x95\xa2}\xce*M+\xc3*K+'
+                         b'\xc7*O\xab\xc0\xaaH\xab\xc4\xaaL\xab\xc2\xaaJ\xab\xc6\xfa\x82V\x9dU\x83V\x93\xf5%\xad'
+                         b'\x16\xab6\xad\x0e\xab.\xad\x1e\xab>\xad\x01\xab!\xad\x11\xab1\xad\t\xab)\xad\x19\xeb+\xda'
+                         b'\xd7\xac\xe6\xb4\x16\xacoh-Y\xadh\xadYmhmY\xedh\xedY\x1dh\x1dY\x9dh\x9dY]h]Y\xddh\xddY=h'
+                         b'=Y\xbdh\xbdY}h}Y\xfdh\xfdY\xdf\xd2\x06\xb0\x06\xca\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02'
+                         b'\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05\xc2\n'
+                         b'\x84\xca\x02\x16\x08j\x81A\xb2\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0'
+                         b'\x02\x16\xb0\x80\x05"n\x81\xc1\xb2\x80\x05,`\x81 \x16\xf8N\x16\x08r\x81!\nr\x81\xa1'
+                         b'b\x0b|\x1fl\xc3\x82nx\xb0\x8d\x08\xefF\xb2F\xd1F\xb3~\xa0\xfd\xc8\x1aC\x1b\xcb\x1a'
+                         b'G\x1b\xcf\x9a@\x9b\xc8\x9aD\x9b\xcc\x9aB\x9b\xca\x9aF\x9b\xce\x9aA\x9b\xc9\x9aE\x9b\xcd\x9a'
+                         b'C\x9b\xcb\xfa\x896\x8f5\x9f\xb6\x80\xb5\x90\xb6\x88\xb5\x98\xf63\xeb\x17\xda\xaf\xac'
+                         b'%\xb4\xa5\xace\xb4\xe5\xac\xdfh\xbf\xb3V\xd0V\xb2V\xd1V\xb3\xd6\xd0\xd6\xb2\xd6\xd1\xd6\xb3'
+                         b'6\xd06\xb26\xd16\xb3\xb6\xd0\xb6\xb2\xb6\xd1\xb6\xb3v\xd0v\xb2\xfe\xa0\xfd\xc9\xdaE\xdb\xcd'
+                         b'\xfa\x8b\xb6\x87\xb5\x97\xb6\x8f\xb5\x9f\xf67\xeb\x00\xed \xeb\x1f\xda\xbf\xacC\xb4\xc3'
+                         b'\xac#\xb4\xa3\xacc\xb4\xe3\xac\x13\xb4\x93\xacS\xb4\xd3\xac3\xb4\xb3\xacs\xb4\xf3'
+                         b'\xac\x0b\xb4\x8b\xacK\xb4\xcb\xac+\xb4\xab\xack\xb4\xeb\xac\x1b\xb4\x9b\xac[\xb4\xdb'
+                         b'\xac;\xb4\xbb\xac{\xb4\xfb\xac\x07\xb4\x87\xacG\xb4\xc7\xac\xffh\xff\xb3\x9e\xd0\x9e'
+                         b'\xb2\x9e\xd1\x9e\xb3^\xd0^\xb2^\xd1^\xb3\xde\xd0\xde\xb2\xde\xc9\x02\x16\xb0\x80\x05'
+                         b',`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0'
+                         b'\x02\x16\xb0\x80\x05\xc2\n\x04\xf5\xf8\xdc\xdd\x16\xb0@\xe8{\t?\xc8\x90'),
  (5, 2, 15, 'saturate'): (b'x\x01M\xcb\xd9\x11\x10T\x0c@\xd1\x94B\x17 \x08\x06Dh#\x9d\x90R\xd2\x05\xca\x1a\x17'
                           b'\xa0\x8dt\x02\xc7\x1f\xc7\xcc\x9c\xf7\xf1n\x12\xf1\xef\xf4C\xcf\xa3\x88\xa4\x19\x96#~\x8ax@'
                           b"R4\xc3r\xc4c\x9d\xa4h\x86\xe5\x88':I\xd1\x0c\xcb\x11?\xeb$E3,G<\xd5I\x8afX\x8ex\xa6\x93"
@@ -102,27 +102,22 @@ mxfp_luts_compressed = \
                           b"')\x9aa9bu\x92\xa2\x19\x96#\xfe\xd4I\x8afX\x8e\xf8K')\x9aa9\xe2o\x9d\xa4h\x86\xe5\x88\x7ft"
                           b'\x92\xa2\x19\x96#\xbe\xe8$E3,G|\xd5I\x8afX\x8e\xf8\xa6\x93\x14\xfd]\xfb\xcf\x0f'
                           b'\xd2\x15\xf0\xcf',
-                          b"x\x01\xed\xddC\x82\x1d\x00\x00D\xc1\x89m\xdb\xb6m\xdb\xb6m'\xab\xd8\xb6m\xdb\xb6m\xdb"
-                          b'v\xb2H\x8e1\x8b\xfau\x83~\x17\xe8\xa0\xa0`\x16\xc2\x16R\x17\xca\x16Z\x17\xc6\x16V\x17'
-                          b'\xce\x16^\x17\xc1\x16Q\x17\xc9\x16Y\x17\xc5\x16U\x17\xcd\x16]\x17\xc3\x16S\x17\xcb\x16[\x17'
-                          b'\xc7\x16W\x17\xcf\x16_\x97\xc0\x96P\x97\xc8\x96X\x97\xc4\x96T\x97\xcc\x96\\\x97'
-                          b'\xc2\x96R\x97\xca\x96Z\x97\xc6\x96V\x97\xce\x96^\x97\xc1\x96Q\x97\xc9\x96Y\x97\xc5\x96U\x97'
-                          b'\xcd\x96]\x97\xc3\x96S\x97\xcb\x96[\x97\xc7\x96W\x97\xcf\x96_W\xc0VPW\xc8VXW\xc4VTW\xccV\\W'
-                          b'\xc2VRW\xcaVZW\xc6VVW\xceV^W\xc1VQW\xc9VYW\xc5VUW\xcdV]W\xc3VSW\xcbV[W\xc7VWW\xcfV_\xd7'
-                          b'\xc0\xd6P\xd7\xc8\xd6X\xd7\xc4\xd6T\xd7\xcc\xd6\\\xd7\xc2\xd6R\xd7\xca\xd6Z\xd7'
-                          b'\xc6\xd6V\xd7\xce\xd6^\xd7\xc1\xd6Q\xd7\xc9\xd6Y\xd7\xc5\xd6U\xd7\xcd\xd6]\xd7\xc3\xd6S\xd7'
-                          b'\xcb\xd6[\xd7\xc7\xd6W\xd7\xcf\xd6_7\xc06P7( X\x0b\xfc\x0b\x08\x14\x08\x14P\x0b'
-                          b'\x04\x05\xb7\xc1\xb6!\xba\xa1\xb6a\xba\xe1\xb6\x11\xba\x91\xb6Q\xba\xd1\xb61\xba\xb1'
-                          b'\xb6q\xba\xf1\xb6\t\xba\x89\xb6I\xba\xc9\xb6)\xba\xa9\xb6i\xba\xe9\xb6\x19\xba\x99'
-                          b'\xb6Y\xba\xd9\xb69\xba\xb9\xb6y\xba\xf9\xb6\x05\xba\x85\xb6E\xba\xc5\xb6%\xba\xa5'
-                          b'\xb6e\xba\xe5\xb6\x15\xba\x95\xb6U\xba\xd5\xb65\xba\xb5\xb6u\xba\xf5\xb6\r\xba\x8d'
-                          b'\xb6M\xba\xcd\xb6-\xba\xad\xb6m\xba\xed\xb6\x1d\xba\x9d\xb6]\xba\xdd\xb6=\xba\xbd'
-                          b'\xb6}\xba\xfd\xb6\x03\xba\x83\xb6C\xba\xc3\xb6#\xba\xa3\xb6c\xba\xe3\xb6\x13\xba\x93'
-                          b'\xb6S\xba\xd3\xb63\xba\xb3\xb6s\xba\xf3\xb6\x0b\xba\x8b\xb6K\xba\xcb\xb6+\xba\xab'
-                          b'\xb6k\xba\xeb\xb6\x1b\xba\x9b\xb6[\xba\xdb\xb6;\xba\xbb\xb6{\xba\xfb\xb6\x07\xba\x87'
-                          b"\xb6G\xba\xc7\xb6'\xba\xa7\xb6g\xba\xe7\xb6\x17\xba\x97\xb6W\xba\xd7\xb67\xba\xb7"
-                          b'\xb6w\xba\xf7\xb6\x0f\xba\x8f\xb6O\xba\xcf\xb6/\xba\xaf\xb6o\xba\xef\xb6\x1f\xba\x9f'
-                          b'\xb6_\xba\xdf\xb6?\xba\xbf\x01\xc1Z@=>\x0f\xec\x0e\x14\x08\x14\xf8\xf7\x1f$\x1d\xcd\x0c'),
+                          b'x\x01\xed\xddC\xa2\x1c\x00\x00D\xc1\xd8\xb6m\xdb\xb6m\xdb66\xb1m\xdb\xb6m\xdb\xb6m'
+                          b',\x92c\xfcEM\xdd\xa0\xdf\x05:X\xb0 \x16\xdc\x16B\x17\xd2\x16J\x17\xda\x16F\x17\xd6'
+                          b'\x16N\x17\xde\x16A\x17\xd1\x16I\x17\xd9\x16E\x17\xd5\x16M\x17\xdd\x16C\x17\xd3\x16K\x17\xdb'
+                          b'\x16G\x17\xd7\x16O\x17\xdf\x96@\x97\xd0\x96H\x97\xd8\x96D\x97\xd4\x96L\x97\xdc\x96B\x97\xd2'
+                          b'\x96J\x97\xda\x96F\x97\xd6\x96N\x97\xde\x96A\x97\xd1\x96I\x97\xd9\x96E\x97\xd5\x96M\x97\xdd'
+                          b'\x96C\x97\xd3\x96K\x97\xdb\x96G\x97\xd7\x96O\x97\xdfV@W\xd0VHW\xd8VDW\xd4VLW\xdcVBW\xd2'
+                          b'VJW\xdaVFW\xd6VNW\xdeVAW\xd1VIW\xd9VEW\xd5VMW\xddVCW\xd3VKW\xdbVGW\xd7VOW\xdf\xd6@\xd7\xd0'
+                          b'\xd6H\xd7\xd8\xd6D\xd7\xd4\xd6L\xd7\xdc\xd6B\xd7\xd2\xd6J\xd7\xda\xd6F\xd7\xd6\xd6N\xd7\xde'
+                          b'\xd6A\xd7\xd1\xd6I\xd7\xd9\xd6E\xd7\xd5\xd6M\xd7\xdd\xd6C\xd7\xd3\xd6K\xd7\xdb\xd6G\xd7\xd7'
+                          b'\xd6O\xd7\xdf6@70 H\x0b\xfc\x0b\x08\x14\x08\x14P\x0b\x0c\nj\x83mCtCm\xc3t\xc3m#t#m'
+                          b'\xa3t\xa3mctcm\xe3t\xe3m\x13t\x13m\x93t\x93mStSm\xd3t\xd3m3t3m\xb3t\xb3mstsm\xf3t\xf3m'
+                          b'\x0bt\x0bm\x8bt\x8bmKtKm\xcbt\xcbm+t+m\xabt\xabmktkm\xebt\xebm\x1bt\x1bm\x9bt\x9bm[t[m'
+                          b"\xdbt\xdbm;t;m\xbbt\xbbm{t{m\xfbt\xfbm\x07t\x07m\x87t\x87mGtGm\xc7t\xc7m't'm\xa7t\xa7mgtgm"
+                          b'\xe7t\xe7m\x17t\x17m\x97t\x97mWtWm\xd7t\xd7m7t7m\xb7t\xb7mwtwm\xf7t\xf7m\x0ft\x0fm'
+                          b'\x8ft\x8fmOtOm\xcft\xcfm/t/m\xaft\xafmotom\xeft\xefm\x1ft\x1fm\x9ft\x9fm_t_m\xdft\xdfm?t?m'
+                          b'\xbft\xbfm\x7ft\x7f\x03\x82\xb4\x80z|\x1e\xd8\x1d(\x10(\xf0\xef?\xe6\xfc\r\x9b'),
  (4, 3, 7, 'overflow'): (b'x\x01\x1d\xcd[\xb5\x90!\x10\x80Q"\x18\x81\x08\xbc{C-@\x04"\xd0\xe0\x10\x81\x08D\xe0\xdd\x1bj'
                          b'\x01"\x10\xe1o\xa0\xfb\xc8Z{\xcd\xbc|C\x08\xff\xdf\xdb\x10:\x9b\xf0.\x84H\xa6\xd2\x19'
                          b'L\x16\x9b\xc3\xe5!\xbc\x0f\xe1\r\x91D\xa6Pit\x06\x93\xc5\xe6py\x08\x1f\xf4D\x12\x99'
@@ -133,32 +128,31 @@ mxfp_luts_compressed = \
                          b"\x87\xcbC\xf8\xa9'\x92\xc8\x14*\x8d\xce`\xb2\xd8\x1c.\x0fa\xeb\x89$2\x85J\xa33\x98,6\x87\xcb"
                          b'C\xf8\xa5\'\x92\xc8\x14*\x8d\xce`\xb2\xd8\x1c.\x0f\xe1\xb7\x9eH"S\xa84:\x83\xc9bs\xb8<\x84'
                          b'?z"\x89L\xa1\xd2\xe8\x0c&\x8b\xcd\xe1\xbe\xee\x7f\xff\x01!\xba\xf7\x9b',
-                         b'x\x01\xed\xdd\x85\xb2\x90\x05\x10@\xe1K\x87t\x83\x94tI\x83\xd2\x1d\xd2\xd2 \xdd\x8dt3C\xa74*'
-                         b'\xdd\x12\x06\x9d"JwHwww\xc3\xe51\xce\\\xfe\xf3\xbd\xc0\xce\x9e\x07\xd8\r\t\x91\x05,`\x01\x0b'
-                         b"X\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,\xf0\xd9\x16\x08'\x0bX\xc0\x02"
-                         b'\x16\x08b\x81\xf0\xb2@\x90\x0bDP\x90\x0bD\x14[ R\xb0E\x0e\xba(\xc1\x165\xac\x8b\xc6\x8aN\xfb'
-                         b'\x82\x15\x83\x16\x93\x15\x8b\x16\x9b\x15\x87\x16\x97\x15\x8f\x16\x9f\x95\x80\x96'
-                         b'\x90\x95\x88\x96\x98\x95\x84\x96\x94\x95\x8c\xf6%+9-\x05+%-\x15+5\xed+V\x1aZZV:ZzV\x06ZFV&Z'
-                         b'fV\x16ZVV6\xda\xd7\xac\xec\xb4\x1c\xac\x9c\xb4\\\xac\xdc\xb4<\xac\xbc\xb4|\xac\xfc\xb4'
-                         b'oX\xdf\xd2\n\xb0\n\xd2\n\xb1\n\xd3\x8a\xb0\x8a\xd2\x8a\xb1\x8a\xd3J\xb0J\xd2J\xb1J\xd3'
-                         b'\xca\xb0\xca\xd2\xca\xb1\xca\xd3\xbecU\xa0UdU\xa2UfU\xa1UeU\xa3}\xcf\xaaN\xab\xc1\xaaI'
-                         b'\xab\xc5\xaaM\xab\xc3\xaaK\xab\xc7\xaaO\xfb\x81\xd5\x80\xd6\x90\xd5\x88\xd6\x98\xd5\x84'
-                         b'\xd6\x94\xd5\x8c\xd6\x9c\xd5\x82\xd6\x92\xd5\x8a\xd6\x9a\xd5\x86\xd6\x96\xd5\x8e'
-                         b"\xd6\x9e\xd5\x81\xd6\x91\xd5\x89\xd6\x99\xf5#\xad\x0b\xab+\xad\x1b\xab;\xad\x07\xab'"
-                         b'\xad\x17\xab7\xad\x0f\xab/\xad\x1f\xab?m\x00k -T\x16\xb0\x80\x05,`\x01\x0bX\xc0'
-                         b'\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,'
-                         b'`\x01\x0bX\x80-\xf0\xd9\xfe5s1\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16'
-                         b'\xb0\x80\x05,`\x01\x0bX $d\x90,`\x01\x0bX \x88\x05\x06\xcb\x02A.0DA.0Tl\x81a\xc16<\xe8F\x04'
-                         b"\xdb\xc8\xb0n\x14k4m\x0ck,\xed'\xd68\xdax\xd6\x04\xdaD\xd6$\xdad\xd6\x14\xdaT\xd6\xcf\xb4"
-                         b'_X\xbf\xd2\xa6\xb1\xa6\xd3f\xb0f\xd2f\xb1f\xd3\xe6\xb0\xe6\xd2\xe6\xb1\xe6\xd3'
-                         b"\x16\xb0\x16\xd2\x16\xb1~\xa3-f-\xa1-e-\xa3\xfd\xce\xfa\x83\xf6'\xeb/\xdar\xd6\n\xdaJ\xd6*"
-                         b'\xdaj\xd6\x1a\xdaZ\xd6:\xdaz\xd6\x06\xdaF\xd6&\xda\xdf\xac\xcd\xb4\x7fX[h\xff\xb2\xfe\xa3mem'
-                         b'\xa3mg\xed\xa0\xedd\xed\xa2\xedf\xed\xa1\xede\xed\xa3\xedg\x1d\xa0\x1dd\x1d\xa2\x1df\x1d'
-                         b'\xa1\xfd\xcf:J;\xc6:N;\xc1:I;\xc5:M;\xc3:K;\xc7:O\xbb\xc0\xbaH\xbb\xc4\xbaL\xbb\xc2\xba'
-                         b'J\xbb\xc6\xbaN\xbb\xc1\xbaI\xbb\xc5\xbaM\xbb\xc3\xbaK\xbb\xc7\xbaO{\xc0zH{\xc4zL{\xc2z'
-                         b'J{\xc6zN{\xc1zI{\xc5zM{\xc3zK{\xc7zO\xfb\xc0\xfaHc\xcf\xf7;\xdd\x02\x16\xb0\x80\x05,'
-                         b'`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02'
-                         b'\x16\xb0\x80\x05,`\x01\x0b\x84~\x02\x87va\xdb'),
+                         b'x\x01\xed\xdc\x05\xb2\x90\x05\x00E\xe1\x87\x80\xa4t\x83tw\x97Jw\x0bHKw\x83\x80\x92Cww7'
+                         b'\x92\xd2\x1dRJww\x97\xa4\x92J\xba\x8c3\x8f\xff|\x1b\xb83g\x017$D\x16\xb0\x80\x05,`\x01'
+                         b'\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\xc0g[ \x8c,`\x01\x0bX '
+                         b'\x88\x05\xbe\x90\x05\x82\\ \xac\x82\\ \x9c\xd8\x02\xe1\x83\xed\xcb\xa0\x8b\x10l\x11'
+                         b'C\xbbH\xac\xc8\xb4(\xac\xa8\xb4\xafX\xd1h\xd1Y1h1Y\xb1h\xb1YqhqY\xf1h\xf1Y\th\tY\x89h\x89Y'
+                         b'Ih_\xb3\x92\xd2\x92\xb1\x92\xd3R\xb0R\xd2R\xb1R\xd3\xd2\xb0\xd2\xd2\xd2\xb1\xd2\xd32\xb0'
+                         b'2\xd22\xb12\xd3\xb2\xb0\xb2\xd2\xb2\xb1\xb2\xd3r\xb0r\xd2r\xb1r\xd3\xf2\xb0\xf2\xd2\xf2\xb1'
+                         b'\xf2\xd3\n\xb0\n\xd2\xbea}K\xfb\x8eU\x88V\x98U\x84V\x94U\x8cV\x9cU\x82V\x92U\x8aV\x9a'
+                         b'U\x86V\x96U\x8eV\x9eU\x81V\x91U\x89V\x99U\x85\xf6=\xab*\xad\x1a\xab:\xed\x07V\rZMV-ZmV\x1dZ]'
+                         b'V=\xda\x8f\xac\xfa\xb4\x06\xac\x86\xb4F\xac\xc6\xb4&\xac\xa6\xb4f\xac\xe6\xb4\x16'
+                         b'\xac\x96\xb4V\xac\xd6\xb46\xac\xb6\xb4v\xac\xf6\xb4\x0e\xac\x8e\xb4N\xac\xce\xb4\x9fX]h]'
+                         b'Y\xddh?\xb3~\xa1ug\xf5\xa0\xf5d\xf5\xa2\xf5f\xf5\xa1}\x92\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80'
+                         b'\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX'
+                         b'\xc0\x02\x16`\x0b\xf4\x95\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0'
+                         b"\x80\x05,\xf0\xf9\x16\xe8'\x0bX\xc0\x02\x16\x08b\x81\xfe\xb2@\x90\x0b\x0cP\x90\x0b\x0c\x14["
+                         b'`P\xb0\r\x0e\xba!\xc164\xb4\x1b\xc6\x1aN\x1b\xc1\x1aI\x1b\xc5\x1aM\x1b\xc3\x1aK\x1b'
+                         b'\xc7\x1aO\x9b\xc0\x9aH\x9b\xc4\x9aL\x9b\xc2\x9aJ\x9b\xc6\x9aN\x9b\xc1\x9aI\x9b\xc5\x9aM\x9b'
+                         b'\xc3\x9aK\x9b\xc7\x9aO[\xc0ZH[\xc4\xfa\x95\xb6\x98\xb5\x84\xb6\x94\xb5\x8c\xb6'
+                         b'\x9c\xb5\x82\xf6\x1bk%m\x15k5m\rk-m\x1dk=m\x03k#m\x13k3m\x0bk+m\x1bk;m\x07\xebw\xda'
+                         b"N\xd6.\xdan\xd6\x1e\xda^\xd6\x1f\xb4?Y\xfbh\xfbY\x07h\x07Y\x87h\x87YGhGY\xc7h\xc7Y'h'Y\xa7h"
+                         b'\xa7YghgY\xe7h\xe7Y\x17h\x17Y\x97h\x97YWhWY\xd7h\xd7Y7h7Y\xb7h\xb7YwhwY\xf7h\xf7Y\x0fh'
+                         b'\x7f\xb1\x1e\xd2\x1e\xb1\x1e\xd3\x9e\xb0\x9e\xd2\x9e\xb1\xfe\xa6\xfd\xc3zN{\xc1zI{\xc5zM'
+                         b'{\xc3\xfa\x97\xf6\x1f\xeb-\xed\x1d\xeb=\xed\x03\xeb#\x8d\xbd\xefw\xdd\x02\x16\xb0\x80\x05,`'
+                         b'\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16\xb0\x80\x05,`\x01\x0bX\xc0\x02\x16'
+                         b'\xb0\x80\x05,`\x01\x0b|\xfa\x1f\xb2\xf6b\xf1'),
  (5, 2, 15, 'overflow'): (b'x\x01M\xcb\xd9\x11\x10T\x0c@\xd1\x94B\x17 \x08\x06Dh#\x9d\x90R\xd2\x05\xca\x1a\x17'
                           b'\xa0\x8dt\x02\xc7\x1f\xc7\xcc\x9c\xf7\xf1n\x12\xf1\xef\xf4C\xcf\xa3\x88\xa4\x19\x96#~\x8ax@'
                           b"R4\xc3r\xc4c\x9d\xa4h\x86\xe5\x88':I\xd1\x0c\xcb\x11?\xeb$E3,G<\xd5I\x8afX\x8ex\xa6\x93"
@@ -169,24 +163,27 @@ mxfp_luts_compressed = \
                           b"')\x9aa9bu\x92\xa2\x19\x96#\xfe\xd4I\x8afX\x8e\xf8K')\x9aa9\xe2o\x9d\xa4h\x86\xe5\x88\x7ft"
                           b'\x92\xa2\x19\x96#\xbe\xe8$E3,G|\xd5I\x8afX\x8e\xf8\xa6\x93\x14\xfd]\xfb\xcf\x0f'
                           b'\xd2\x15\xf0\xcf',
-                          b'x\x01\xed\xddS\xd6\x1d\x06\x00\x85\xd1?\xb6m[\r\x1a\xdb\xb6\xd94nl\xbe\xc4\xb6m\xdb'
-                          b'v\xd2\xd8n\xd0\xd8\xb6\xd6J\x86q\x1f\xf6\xdd38\xdf\x04NHH\x80\x85\xb2\x85\xd6\x85\xb1'
-                          b'\x85\xd5\x85\xb3\x85\xd7E\xb0E\xd4E\xb2E\xd6E\xb1E\xd5E\xb3E\xd7\xc5\xb0\xc5\xd4\xc5\xb2'
-                          b'\xc5\xd6\xc5\xb1\xc5\xd5\xc5\xb3\xc5\xd7%\xb0%\xd4%\xb2%\xd6%\xb1%\xd5%\xb3%\xd7\xa5\xb0'
-                          b'\xa5\xd4\xa5\xb2\xa5\xd6\xa5\xb1\xa5\xd5\xa5\xb3\xa5\xd7e\xb0e\xd4e\xb2e\xd6e\xb1e\xd5e\xb3'
-                          b'e\xd7\xe5\xb0\xfd\xa1\xcbi\xcb\xa5\xcbm\xcb\xa3\xfb\xd3\x96W\x97\xcf\x96_W\xc0VPW\xc8'
-                          b'VXW\xc4VTW\xccV\\W\xc2VRW\xcaVZW\xc6VVW\xceV^W\xc1VQW\xc9VYW\xc5VUW\xcdV]W\xc3VSW\xcb'
-                          b'V[W\xc7VWW\xcfV_\xd7\xc0\xd6P\xd7\xc8\xd6X\xd7\xc4\xd6T\xd7\xcc\xf6\x97\xae\xb9\xedo]\x0b'
-                          b'[K]+[k]\x1b[[];\xdb?\xba\xf6\xb6\x0e\xba\x8e\xb6N\xba\xce\xb6.\xba\xae\xb6n\xba\xee'
-                          b'\xb6\x1e\xba\x9e\xb6^\xba\xde\xb6>\xba\xbe\xb6~\xba\xfe\xb6\x01\x81\xf6+(X X@-\x10'
-                          b'\x12h\x03m\x83t\x83mCtCm\xc3t\xc3m#t#m\xa3t\xa3mctcm\xe3t\xe3m\x13t\x13m\x93t\x93mStSm'
-                          b'\xd3t\xd3m3t3m\xb3t\xb3mstsm\xf3t\xf3m\x0bt\x0bm\x8bt\x8bmKtKm\xcbt\xcbm+t+m\xabt\xabmktkm'
-                          b'\xebt\xebm\x1bt\x1bm\x9bt\x9bm[t[m\xdbt\xdbm;t;m\xbbt\xbbm{t{m\xfbt\xfbm\x07t\x07m'
-                          b'\x87t\x87mGtGm\xff\xea\x8e\xd9\x8e\xebN\xd8N\xeaN\xd9N\xeb\xce\xd8\xce\xea\xce\xd9'
-                          b'\xce\xeb.\xd8.\xea.\xd9.\xeb\xae\xd8\xae\xea\xae\xd9\xae\xebn\xd8\xfe\xd3\xdd\xb4'
-                          b'\xdd\xd2\xdd\xb6\xdd\xd1\xfdo\xbb\xab\xbbg\xbb\xaf{`{\xa8{d{\xac{b{\xaa{f{\xae{a{\xa9{e'
-                          b'{\xad{c{\xab{g{\xaf\xfb`\xfb\xa8\xfbd\xfb\xac\xfbb\xfb\xaa\xfbf\xfb\xae\xfba\xfb\x19h\xea'
-                          b'\xf1ypw\xb0@\xb0\xc0\xaf\xdf\xf0\x99\xce\x0e')}
+                          b'x\x01\xed\xddS\xb6\x1e\x06\x00\x85\xd1\x1b\xdb\xb6\x1b\xdb\xb6\x9b\x06\x8dm\xdbz\x88'
+                          b"m\xabI\x1b\xa3\xb1m\xdb\xb6mg\xad\x9ba\xdc\x87\xfd\xef\x19\x9co\x02'((\x84\x85\xb2"
+                          b'\x85\xd6\x85\xb1\x85\xd5\x85\xb3\x85\xd7E\xb0E\xd4E\xb2E\xd6E\xb1E\xd5E\xb3E\xd7\xc5\xb0'
+                          b'\xc5\xd4\xc5\xb2\xc5\xd6\xc5\xb1\xc5\xd5\xc5\xb3\xc5\xd7%\xb0%\xd4%\xb2%\xd6%\xb1%\xd5%\xb3'
+                          b'%\xd7\xa5\xb0\xa5\xd4\xa5\xb2\xa5\xd6\xa5\xb1\xa5\xd5\xa5\xb3\xfd\xa1Ko\xcb\xa0\xcbh'
+                          b'\xcb\xa4\xcbl\xcb\xa2\xcbj\xcb\xa6\xcbn\xcb\xa1\xcbi\xcb\xa5\xcbm\xcb\xa3\xcbk\xcb\xa7\xcbo'
+                          b'+\xa0+h+\xa4+l+\xa2+j+\xa6+n+\xa1+i+\xa5+m+\xa3+k+\xa7+o\xab\xa0\xabh\xab\xa4\xabl'
+                          b'\xfbSW\xc5\xf6\x97\xae\xaa\xad\x9a\xae\xba\xad\x86\xeeo[M]-[m]\x1d[]]=[}]\x03[C]#[c]\x13'
+                          b"[S]3[s]\x0b[K]+[k]\x1b[[];[{]\x07[G]'[g]\x17[W]7[w]\x0f[O]/[o]\x1f[_]?[\x7f\xdd\x00"
+                          b'\xdb\xc0\x90\x16\x1c\x10(\x10(\xa0\x16\x18\x14\xd2\x06\xdb\x86\xe8\x86\xda\x86\xe9\x86\xdb'
+                          b'F\xe8F\xdaF\xe9F\xdb\xc6\xe8\xc6\xda\xc6\xe9\xc6\xdb&\xe8&\xda&\xe9&\xdb\xa6\xe8\xa6\xda'
+                          b'\xa6\xe9\xa6\xdbf\xe8f\xdaf\xe9f\xdb\xe6\xe8\xe6\xda\xe6\xe9\xfe\xb1\xcd\xd7-\xb0'
+                          b'\xfd\xab\xfb\xcf\xb6P\xb7\xc8\xb6X\xb7\xc4\xb6T\xb7\xcc\xb6\\\xb7\xc2\xb6R\xb7\xca'
+                          b'\xf6\xbfn\xb5m\x8dn\xadm\x9dn\xbdm\x83n\xa3m\x93n\xb3m\x8bn\xabm\x9bn\xbbm\x87n\xa7'
+                          b'm\x97n\xb7m\x8fn\xafm\x9fn\xbf\xed\x80\xee\xa0\xed\x90\xee\xb0\xed\x88\xee\xa8'
+                          b'\xed\x98\xee\xb8\xed\x84\xee\xa4\xed\x94\xee\xb4\xed\x8c\xee\xac\xed\x9c\xee\xbc'
+                          b'\xed\x82\xee\xa2\xed\x92\xee\xb2\xed\x8a\xee\xaa\xed\x9a\xee\xba\xed\x86\xee\xa6'
+                          b'\xed\x96\xee\xb6\xed\x8e\xee\xae\xed\x9e\xee\xbe\xed\x81\xee\xa1\xed\x91\xee\xb1'
+                          b'\xed\x89\xee\xa9\xed\x99\xee\xb9\xed\x85\xee\xa5\xed\x95\xee\xb5\xed\x8d\xee\xad'
+                          b'\xed\x9d\xee\xbd\xed\x83\xee\xa3\xed\x93\xee\xb3\xed\x8b\xee\xab\xed\x9b\xee\xbb'
+                          b'\xed\x87\xee\xa7\xedWHS\x8f\xcf\x03\xbb\x03\x05\x02\x05\x82\x7f\x03\xb3\x87\x0e\x9d')}
 
 
 binary8_luts_compressed = \

bitstring/mxfp.py

@@ -6,6 +6,7 @@ from bitstring.luts import mxfp_luts_compressed
 import zlib
 from typing import Optional
 
+
 def round_to_nearest_ties_to_even(lut_int_to_float, lower: int, f: float) -> Optional[int]:
     upper = lower + 1
     # Special case for LUTs without a negative zero.
@@ -56,7 +57,7 @@ class MXFPFormat:
                 self.pos_clamp_value = 0b01111100  # +inf
                 self.neg_clamp_value = 0b11111100  # -inf
 
-        # If we calculate these LUTs now now it creates a bootstrap problem in generate_luts.py.
+        # If we calculate these LUTs now it creates a bootstrap problem in generate_luts.py.
         self.lut_float16_to_mxfp = None
         self.lut_int_to_float = None
 
@@ -91,7 +92,15 @@ class MXFPFormat:
         # The output int has the binary sequence needed for the float.
         length = 1 + self.exp_bits + self.mantissa_bits
         values = 1 << length
-        if f >= 0:
+        # First get the NaN case out of the way
+        if math.isnan(f):
+            if length == 8:
+                return 0xff  # Works for both e5m2 and e4m3
+            # For smaller lengths, NaN isn't supported so we instead return an invalid value to detect later
+            return 0xff
+        # This is so we can distinguish between 0.0 and -0.0
+        is_positive = math.copysign(1.0, f) == 1.0
+        if is_positive:
             # Positive, so top bit is not set
             for i in range(values // 2 - 1):
                 upper = self.lut_int_to_float[i + 1]
@@ -101,7 +110,7 @@ class MXFPFormat:
                 if x is not None:
                     return x
             return self.pos_clamp_value
-        if f < 0:
+        else:
             # Negative, so top bit is set
             for i in range(values // 2, values - 1):
                 lower = self.lut_int_to_float[i + 1]
@@ -112,11 +121,6 @@ class MXFPFormat:
                     return x
             # Clip to negative max
             return self.neg_clamp_value
-        assert math.isnan(f)
-        if length == 8:
-            return 0xff  # Works for both e5m2 and e4m3
-        # For smaller lengths, NaN isn't supported so we instead return an invalid value to detect later
-        return 0xff
 
     def createLUT_for_int_to_float(self) -> array.array:
         """Create a LUT to convert an int in representing a MXFP float into a Python float"""
@@ -154,7 +158,8 @@ class MXFPFormat:
         length = 1 + self.exp_bits + self.mantissa_bits
         if length == 8:
             import gfloat
-            fi = gfloat.formats.format_info_ocp_e5m2 if self.exp_bits == 5 else gfloat.formats.format_info_ocp_e4m3
+            from gfloat.formats import format_info_ocp_e5m2, format_info_ocp_e4m3
+            fi = format_info_ocp_e5m2 if self.exp_bits == 5 else format_info_ocp_e4m3
 
             fp16_to_fp8 = bytearray(1 << 16)
             for i in range(1 << 16):
@@ -164,7 +169,11 @@ class MXFPFormat:
                 if math.isnan(fp):
                     fp8_i = 0b11111111
                 else:
-                    fp8_i = self.lut_int_to_float.index(fp)
+                    # Special case for negative zero
+                    if fp == 0.0 and math.copysign(1.0, fp) == -1.0:
+                        fp8_i = 0b10000000
+                    else:
+                        fp8_i = self.lut_int_to_float.index(fp)
                 fp16_to_fp8[i] = fp8_i
             return bytes(fp16_to_fp8)
         else:
@@ -174,9 +183,6 @@ class MXFPFormat:
                 b = struct.pack('>H', i)
                 f, = struct.unpack('>e', b)
                 fp8_i = self.slow_float_to_int(f)
-                if fp8_i == 1 << (self.exp_bits + self.mantissa_bits):
-                    # Got back int representing binary digits for negative zero. Just convert to positive zero instead.
-                    fp8_i = 0
                 fp16_to_fp8[i] = fp8_i
             return bytes(fp16_to_fp8)
 

bitstring/utils.py

@@ -21,11 +21,11 @@ MULTIPLICATIVE_RE: Pattern[str] = re.compile(r'^(?P<factor>.*)\*(?P<token>.+)')
 LITERAL_RE: Pattern[str] = re.compile(r'^(?P<name>0([xob]))(?P<value>.+)', re.IGNORECASE)
 
 # An endianness indicator followed by one or more struct.pack codes
-STRUCT_PACK_RE: Pattern[str] = re.compile(r'^(?P<endian>[<>@=]){1}(?P<fmt>(?:\d*[bBhHlLqQefd])+)$')
+STRUCT_PACK_RE: Pattern[str] = re.compile(r'^(?P<endian>[<>@=])(?P<fmt>(?:\d*[bBhHlLqQefd])+)$')
 # The same as above, but it doesn't insist on an endianness as it's byteswapping anyway.
 BYTESWAP_STRUCT_PACK_RE: Pattern[str] = re.compile(r'^(?P<endian>[<>@=])?(?P<fmt>(?:\d*[bBhHlLqQefd])+)$')
 # An endianness indicator followed by exactly one struct.pack codes
-SINGLE_STRUCT_PACK_RE: Pattern[str] = re.compile(r'^(?P<endian>[<>@=]){1}(?P<fmt>[bBhHlLqQefd])$')
+SINGLE_STRUCT_PACK_RE: Pattern[str] = re.compile(r'^(?P<endian>[<>@=])(?P<fmt>[bBhHlLqQefd])$')
 
 # A number followed by a single character struct.pack code
 STRUCT_SPLIT_RE: Pattern[str] = re.compile(r'\d*[bBhHlLqQefd]')
@@ -74,6 +74,7 @@ def structparser(m: Match[str]) -> List[str]:
         tokens = [REPLACEMENTS_BE[c] for c in fmt]
     return tokens
 
+
 @functools.lru_cache(CACHE_SIZE)
 def parse_name_length_token(fmt: str, **kwargs) -> Tuple[str, Optional[int]]:
     # Any single token with just a name and length
@@ -94,6 +95,7 @@ def parse_name_length_token(fmt: str, **kwargs) -> Tuple[str, Optional[int]]:
             raise ValueError(f"Can't parse 'name[:]length' token '{fmt}'.")
     return name, length
 
+
 @functools.lru_cache(CACHE_SIZE)
 def parse_single_struct_token(fmt: str) -> Optional[Tuple[str, Optional[int]]]:
     if m := SINGLE_STRUCT_PACK_RE.match(fmt):
@@ -110,6 +112,7 @@ def parse_single_struct_token(fmt: str) -> Optional[Tuple[str, Optional[int]]]:
     else:
         return None
 
+
 @functools.lru_cache(CACHE_SIZE)
 def parse_single_token(token: str) -> Tuple[str, str, Optional[str]]:
     if (equals_pos := token.find('=')) == -1:
@@ -132,6 +135,7 @@ def parse_single_token(token: str) -> Tuple[str, str, Optional[str]]:
         length = token
     return name, length, value
 
+
 @functools.lru_cache(CACHE_SIZE)
 def preprocess_tokens(fmt: str) -> List[str]:
     # Remove whitespace and expand brackets
@@ -143,7 +147,7 @@ def preprocess_tokens(fmt: str) -> List[str]:
     final_tokens = []
 
     for meta_token in meta_tokens:
-        if  meta_token == '':
+        if meta_token == '':
             continue
         # Extract factor and actual token if a multiplicative factor exists
         factor = 1
@@ -204,6 +208,7 @@ def tokenparser(fmt: str, keys: Tuple[str, ...] = ()) -> \
 
 BRACKET_RE = re.compile(r'(?P<factor>\d+)\*\(')
 
+
 def expand_brackets(s: str) -> str:
     """Expand all brackets."""
     while True:

{bitstring-4.2.2.dist-info → bitstring-4.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bitstring
-Version: 4.2.2
+Version: 4.2.3
 Summary: Simple construction, analysis and modification of binary data.
 Author-email: Scott Griffiths <dr.scottgriffiths@gmail.com>
 Project-URL: homepage, https://github.com/scott-griffiths/bitstring
@@ -40,26 +40,13 @@ It has been actively maintained since 2006.
 [![Pepy Total Downlods](https://img.shields.io/pepy/dt/bitstring?logo=python&logoColor=white&labelColor=blue&color=blue)](https://www.pepy.tech/projects/bitstring)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/bitstring?label=%40&labelColor=blue&color=blue)](https://pypistats.org/packages/bitstring)
 
-
-News
 ----
-**May 2024**: bitstring 4.2.2 released.
- 
-New in version 4.2:
-
-* Dropped support for Python 3.7. Minimum version is now 3.8.
-* A new `Dtype` class can be optionally used to specify types.
-* The `bitstring.options` object is now the preferred method for changing module options.
-* New `fromstring` method as another way to create bitstrings from formatted strings.
-* More types can now be pretty printed.
-* A range of 8-bit, 6-bit and even 4-bit floating point formats added (beta):
-* Performance improvements.
 
-See the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt) for details. Please let me know if you encounter any problems.
+> [!NOTE]
+> To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.md).
 
 
-Overview
---------
+# Overview
 
 * Efficiently store and manipulate binary data in idiomatic Python.
 * Create bitstrings from hex, octal, binary, files, formatted strings, bytes, integers and floats of different endiannesses.
@@ -70,8 +57,8 @@ Overview
 * Rich API - chances are that whatever you want to do there's a simple and elegant way of doing it.
 * Open source software, released under the MIT licence.
 
-Documentation
--------------
+# Documentation
+
 Extensive documentation for the bitstring module is available.
 Some starting points are given below:
 
@@ -81,67 +68,66 @@ Some starting points are given below:
 
 There is also an introductory walkthrough notebook on [binder](https://mybinder.org/v2/gh/scott-griffiths/bitstring/main?labpath=doc%2Fwalkthrough.ipynb).
 
-Release Notes
--------------
-
-To see what been added, improved or fixed, and also to see what's coming in the next version, see the [release notes](https://github.com/scott-griffiths/bitstring/blob/main/release_notes.txt).
-
-Examples
---------
+# Examples
 
 ### Installation
-
-    $ pip install bitstring
+```
+$ pip install bitstring
+```
 
 ### Creation
-
-     >>> from bitstring import Bits, BitArray, BitStream, pack
-     >>> a = BitArray(bin='00101')
-     >>> b = Bits(a_file_object)
-     >>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
-     >>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
-     >>> e = pack('<16h', *range(16))
+```pycon
+>>> from bitstring import Bits, BitArray, BitStream, pack
+>>> a = BitArray(bin='00101')
+>>> b = Bits(a_file_object)
+>>> c = BitArray('0xff, 0b101, 0o65, uint6=22')
+>>> d = pack('intle16, hex=a, 0b1', 100, a='0x34f')
+>>> e = pack('<16h', *range(16))
+```
 
 ### Different interpretations, slicing and concatenation
-
-     >>> a = BitArray('0x3348')
-     >>> a.hex, a.bin, a.uint, a.float, a.bytes
-     ('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
-     >>> a[10:3:-1].bin
-     '0101100'
-     >>> '0b100' + 3*a
-     BitArray('0x866906690669, 0b000')
+```pycon
+>>> a = BitArray('0x3348')
+>>> a.hex, a.bin, a.uint, a.float, a.bytes
+('3348', '0011001101001000', 13128, 0.2275390625, b'3H')
+>>> a[10:3:-1].bin
+'0101100'
+>>> '0b100' + 3*a
+BitArray('0x866906690669, 0b000')
+```
 
 ### Reading data sequentially
-
-     >>> b = BitStream('0x160120f')
-     >>> b.read(12).hex
-     '160'
-     >>> b.pos = 0
-     >>> b.read('uint12')
-     352
-     >>> b.readlist('uint12, bin3')
-     [288, '111']
+```pycon
+>>> b = BitStream('0x160120f')
+>>> b.read(12).hex
+'160'
+>>> b.pos = 0
+>>> b.read('uint12')
+352
+>>> b.readlist('uint12, bin3')
+[288, '111']
+```
 
 ### Searching, inserting and deleting
-
-     >>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
-     >>> c.find('0x48')
-     (8,)
-     >>> c.replace('0b001', '0xabc')
-     >>> c.insert('0b0000', pos=3)
-     >>> del c[12:16]
+```pycon
+>>> c = BitArray('0b00010010010010001111')   # c.hex == '0x1248f'
+>>> c.find('0x48')
+(8,)
+>>> c.replace('0b001', '0xabc')
+>>> c.insert('0b0000', pos=3)
+>>> del c[12:16]
+```
 
 ### Arrays of fixed-length formats
-
-     >>> from bitstring import Array
-     >>> a = Array('uint7', [9, 100, 3, 1])
-     >>> a.data
-     BitArray('0x1390181')
-     >>> a[::2] *= 5
-     >>> a
-     Array('uint7', [45, 100, 15, 1])
-
+```pycon
+>>> from bitstring import Array
+>>> a = Array('uint7', [9, 100, 3, 1])
+>>> a.data
+BitArray('0x1390181')
+>>> a[::2] *= 5
+>>> a
+Array('uint7', [45, 100, 15, 1])
+```
 
 
 <sub>Copyright (c) 2006 - 2024 Scott Griffiths</sub>

bitstring-4.2.3.dist-info/RECORD

@@ -0,0 +1,22 @@
+bitstring/__init__.py,sha256=GjT0V01IeR3DBanzVa5utd4csONZx-PUSr6H0fuXnNU,13899
+bitstring/__main__.py,sha256=Lg6ARiAqKssp_uj1msYpiTGDybhJRshQmeftQ-yTpc0,1658
+bitstring/array_.py,sha256=d4vuZAc0ecJC95RD5_WPApehyH-ZGms4pcxl2I0R90I,36201
+bitstring/bitarray_.py,sha256=kZTVYBo32vQuhQ4TZQldQkqRE5OMPVoKCoxEfKOTg8U,22319
+bitstring/bits.py,sha256=N2bszuYM_WrTfqx-5-m56Vu_XgPZLeTta4xysBqCSYs,76754
+bitstring/bitstore.py,sha256=jHk1cwBPqCJoYq2TEgIE37u_7K8HZq5K0L__X8edMgc,10337
+bitstring/bitstore_helpers.py,sha256=6UHBomeOZlfQmY_Wa17U1zi7FBo73n2D9GPPmPztIrk,9107
+bitstring/bitstream.py,sha256=Hu1ZpcCeP6lfpJiKAwKoJI22A-vsKATN1F2RvnS3rFY,29017
+bitstring/bitstring_options.py,sha256=54Io4xLDylwXdRQpb12eNkSpSXQhRTW9Aidx7G42h7w,3560
+bitstring/dtypes.py,sha256=oBrcavnz15vaBZ_GOVm0tOaW6Ml0oXoz8RyZSyqG6Zo,16897
+bitstring/exceptions.py,sha256=7O3oVJJgvUOadqIzg6U-8fUGyOTu_lmjbMtX3yPc18o,553
+bitstring/fp8.py,sha256=8CIiGlijn9OmBwdpJOl-1oVPUY6qVL2jGl1N8u8LjAg,3768
+bitstring/luts.py,sha256=KPuXC9MvTOQSOlb0bFBKbnuxXuVBYlhaFEdIgSrwtzs,27072
+bitstring/methods.py,sha256=3JM4jo8B6r3xQYY2nvbibmf7byQYTHTZye0F8D2lF10,4351
+bitstring/mxfp.py,sha256=IxXK0SZy5RTD883YwATg6tlqVfl1uCFQplp5BVBwx9Q,9058
+bitstring/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bitstring/utils.py,sha256=tuWHppQUcCVLbtrZoO7eUkpNk6pJLtsOZT7QdWADW78,9221
+bitstring-4.2.3.dist-info/LICENSE,sha256=NwXu1akj812b-sofEOkTbMhNbldlcK7GYb2mmZHxKeo,1106
+bitstring-4.2.3.dist-info/METADATA,sha256=aUUR8ljmKXchDLSPxTGzHot_7Wi659yUYUWS5Zi-3Ek,5017
+bitstring-4.2.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bitstring-4.2.3.dist-info/top_level.txt,sha256=9Xh4qfKH0fMhwxzzkSBk3uzTRGiYPPM1FuYFAgCB-ks,10
+bitstring-4.2.3.dist-info/RECORD,,

bitstring-4.2.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-bitstring/__init__.py,sha256=cSFzwMWpgUBbvhQGZpW9bl10oPVTVROMa9Au8I75FOY,13972
-bitstring/__main__.py,sha256=p0n1Dy1TvWtIYQPuUiTwZT70PxpdnML7h4pxJP423dU,1657
-bitstring/array_.py,sha256=dlknDIuqz1urgkHMMQnv5HaoZ8gPNBAMyGw2QF-UHvs,35860
-bitstring/bitarray_.py,sha256=rtrkJwIODWNA1ca06x3p2BV1lka-BJDSOHOFsw8WbNg,22285
-bitstring/bits.py,sha256=IG7zXU3rF0iq5_pWJuvahja8Yc-y5G3j-rNivHFr0i0,76821
-bitstring/bitstore.py,sha256=0o2-PUixhRToCpH43MNsjJE1THVQib3DcbMICuNZnZ0,10326
-bitstring/bitstore_helpers.py,sha256=ZaMU9WRWnE4FRP2tDveii25yKFnOcMrdHBCQdBFcf8A,9068
-bitstring/bitstream.py,sha256=w52K1yvRTA0Trl6-tq0oVwTUYtz_5O3mvsQEVEpp1V8,29016
-bitstring/bitstring_options.py,sha256=lUQu_3mFf4y58nPwrwap_mLiu7ydGWLp8x_dAEW2W4Y,3558
-bitstring/dtypes.py,sha256=cW8yLYCbrKWsMOGYUNJ-a8bszg-cJJsHrVzajsocPCw,16892
-bitstring/exceptions.py,sha256=xuatJ43eWemtEnfxKNNtK3_7RNhnzqxVodTlHhvKDbg,554
-bitstring/fp8.py,sha256=8CIiGlijn9OmBwdpJOl-1oVPUY6qVL2jGl1N8u8LjAg,3768
-bitstring/luts.py,sha256=M-Qwr_SKr8GId0QKWavq4edHTv7qnVUFr0Vc1m9O7pY,27340
-bitstring/methods.py,sha256=3JM4jo8B6r3xQYY2nvbibmf7byQYTHTZye0F8D2lF10,4351
-bitstring/mxfp.py,sha256=MSliuiofx8uM0HpqoBnYpAx7ih9V0Knx8KcFy9_zSho,8861
-bitstring/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bitstring/utils.py,sha256=yCf0G3l54YXNPMSBS9bMgt2NQBWwbNqzDAcGRz_Ymn4,9223
-bitstring-4.2.2.dist-info/LICENSE,sha256=NwXu1akj812b-sofEOkTbMhNbldlcK7GYb2mmZHxKeo,1106
-bitstring-4.2.2.dist-info/METADATA,sha256=IwJ1xLsqB-Tn65n1RPTGOLND-rLDEhSGPt5h-KglpoE,5846
-bitstring-4.2.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bitstring-4.2.2.dist-info/top_level.txt,sha256=9Xh4qfKH0fMhwxzzkSBk3uzTRGiYPPM1FuYFAgCB-ks,10
-bitstring-4.2.2.dist-info/RECORD,,