# Source code for fontTools.ttLib.tables.TupleVariation

    from fontTools.misc.fixedTools import (
        fixedToFloat as fi2fl,
        floatToFixed as fl2fi,
        floatToFixedToStr as fl2str,
        strToFixedToFloat as str2fl,
        otRound,
    )
    from fontTools.misc.textTools import safeEval
    import array
    from collections import Counter, defaultdict
    import io
    import logging
    import struct
    import sys

    # https://www.microsoft.com/typography/otspec/otvarcommonformats.htm

    EMBEDDED_PEAK_TUPLE = 0x8000
    INTERMEDIATE_REGION = 0x4000
    PRIVATE_POINT_NUMBERS = 0x2000

    DELTAS_ARE_ZERO = 0x80
    DELTAS_ARE_WORDS = 0x40
    DELTAS_ARE_LONGS = 0xC0
    DELTAS_SIZE_MASK = 0xC0
    DELTA_RUN_COUNT_MASK = 0x3F

    POINTS_ARE_WORDS = 0x80
    POINT_RUN_COUNT_MASK = 0x7F

    TUPLES_SHARE_POINT_NUMBERS = 0x8000
    TUPLE_COUNT_MASK = 0x0FFF
    TUPLE_INDEX_MASK = 0x0FFF

    log = logging.getLogger(__name__)

    class TupleVariation(object):
        def __init__(self, axes, coordinates):
            self.axes = axes.copy()
            self.coordinates = list(coordinates)

        def __repr__(self):
            axes = ",".join(
                sorted(["%s=%s" % (name, value) for (name, value) in self.axes.items()])
            )
            return "<TupleVariation %s %s>" % (axes, self.coordinates)

        def __eq__(self, other):
            return self.coordinates == other.coordinates and self.axes == other.axes

        def getUsedPoints(self):
            # Empty set means "all points used".
            if None not in self.coordinates:
                return frozenset()
            used = frozenset([i for i, p in enumerate(self.coordinates) if p is not None])
            # Return None if no points used.
            return used if used else None

        def hasImpact(self):
            """Returns True if this TupleVariation has any visible impact.

            If the result is False, the TupleVariation can be omitted from the font
            without making any visible difference.
            """
            return any(c is not None for c in self.coordinates)

        def toXML(self, writer, axisTags):
            writer.begintag("tuple")
            writer.newline()
            for axis in axisTags:
                value = self.axes.get(axis)
                if value is not None:
                    minValue, value, maxValue = value
                    defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
                    defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
                    if minValue == defaultMinValue and maxValue == defaultMaxValue:
                        writer.simpletag("coord", axis=axis, value=fl2str(value, 14))
                    else:
                        attrs = [
                            ("axis", axis),
                            ("min", fl2str(minValue, 14)),
                            ("value", fl2str(value, 14)),
                            ("max", fl2str(maxValue, 14)),
                        ]
                        writer.simpletag("coord", attrs)
                    writer.newline()
            wrote_any_deltas = False
            for i, delta in enumerate(self.coordinates):
                if type(delta) == tuple and len(delta) == 2:
                    writer.simpletag("delta", pt=i, x=delta[0], y=delta[1])
                    writer.newline()
                    wrote_any_deltas = True
                elif type(delta) == int:
                    writer.simpletag("delta", cvt=i, value=delta)
                    writer.newline()
                    wrote_any_deltas = True
                elif delta is not None:
                    log.error("bad delta format")
                    writer.comment("bad delta #%d" % i)
                    writer.newline()
                    wrote_any_deltas = True
            if not wrote_any_deltas:
                writer.comment("no deltas")
                writer.newline()
            writer.endtag("tuple")
            writer.newline()

        def fromXML(self, name, attrs, _content):
            if name == "coord":
                axis = attrs["axis"]
                value = str2fl(attrs["value"], 14)
                defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
                defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
                minValue = str2fl(attrs.get("min", defaultMinValue), 14)
                maxValue = str2fl(attrs.get("max", defaultMaxValue), 14)
                self.axes[axis] = (minValue, value, maxValue)
            elif name == "delta":
                if "pt" in attrs:
                    point = safeEval(attrs["pt"])
                    x = safeEval(attrs["x"])
                    y = safeEval(attrs["y"])
                    self.coordinates[point] = (x, y)
                elif "cvt" in attrs:
                    cvt = safeEval(attrs["cvt"])
                    value = safeEval(attrs["value"])
                    self.coordinates[cvt] = value
                else:
                    log.warning("bad delta format: %s" % ", ".join(sorted(attrs.keys())))

        def compile(
            self, axisTags, sharedCoordIndices={}, pointData=None, *, optimizeSize=True
        ):
            assert set(self.axes.keys()) <= set(axisTags), (
                "Unknown axis tag found.",
                self.axes.keys(),
                axisTags,
            )

            tupleData = []
            auxData = []

            if pointData is None:
                usedPoints = self.getUsedPoints()
                if usedPoints is None:  # Nothing to encode
                    return b"", b""
                pointData = self.compilePoints(usedPoints)

            coord = self.compileCoord(axisTags)
            flags = sharedCoordIndices.get(coord)
            if flags is None:
                flags = EMBEDDED_PEAK_TUPLE
                tupleData.append(coord)

            intermediateCoord = self.compileIntermediateCoord(axisTags)
            if intermediateCoord is not None:
                flags |= INTERMEDIATE_REGION
                tupleData.append(intermediateCoord)

            # pointData of b'' implies "use shared points".
            if pointData:
                flags |= PRIVATE_POINT_NUMBERS
                auxData.append(pointData)

            auxData.append(self.compileDeltas(optimizeSize=optimizeSize))
            auxData = b"".join(auxData)

            tupleData.insert(0, struct.pack(">HH", len(auxData), flags))
            return b"".join(tupleData), auxData

        def compileCoord(self, axisTags):
            result = []
            axes = self.axes
            for axis in axisTags:
                triple = axes.get(axis)
                if triple is None:
                    result.append(b"\0\0")
                else:
                    result.append(struct.pack(">h", fl2fi(triple[1], 14)))
            return b"".join(result)

        def compileIntermediateCoord(self, axisTags):
            needed = False
            for axis in axisTags:
                minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
                defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
                defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
                if (minValue != defaultMinValue) or (maxValue != defaultMaxValue):
                    needed = True
                    break
            if not needed:
                return None
            minCoords = []
            maxCoords = []
            for axis in axisTags:
                minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
                minCoords.append(struct.pack(">h", fl2fi(minValue, 14)))
                maxCoords.append(struct.pack(">h", fl2fi(maxValue, 14)))
            return b"".join(minCoords + maxCoords)

        @staticmethod
        def decompileCoord_(axisTags, data, offset):
            coord = {}
            pos = offset
            for axis in axisTags:
                coord[axis] = fi2fl(struct.unpack(">h", data[pos : pos + 2])[0], 14)
                pos += 2
            return coord, pos

        @staticmethod
        def compilePoints(points):
            # If the set consists of all points in the glyph, it gets encoded with
            # a special encoding: a single zero byte.
            #
            # To use this optimization, points passed in must be empty set.
            # The following two lines are not strictly necessary as the main code
            # below would emit the same. But this is most common and faster.
            if not points:
                return b"\0"

            # In the 'gvar' table, the packing of point numbers is a little surprising.
            # It consists of multiple runs, each being a delta-encoded list of integers.
            # For example, the point set {17, 18, 19, 20, 21, 22, 23} gets encoded as
            # [6, 17, 1, 1, 1, 1, 1, 1]. The first value (6) is the run length minus 1.
            # There are two types of runs, with values being either 8 or 16 bit unsigned
            # integers.
            points = list(points)
            points.sort()
            numPoints = len(points)

            result = bytearray()
            # The binary representation starts with the total number of points in the set,
            # encoded into one or two bytes depending on the value.
            if numPoints < 0x80:
                result.append(numPoints)
            else:
                result.append((numPoints >> 8) | 0x80)
                result.append(numPoints & 0xFF)

            MAX_RUN_LENGTH = 127
            pos = 0
            lastValue = 0
            while pos < numPoints:
                runLength = 0

                headerPos = len(result)
                result.append(0)

                useByteEncoding = None
                while pos < numPoints and runLength <= MAX_RUN_LENGTH:
                    curValue = points[pos]
                    delta = curValue - lastValue
                    if useByteEncoding is None:
                        useByteEncoding = 0 <= delta <= 0xFF
                    if useByteEncoding and (delta > 0xFF or delta < 0):
                        # we need to start a new run (which will not use byte encoding)
                        break
                    # TODO This never switches back to a byte-encoding from a short-encoding.
                    # That's suboptimal.
                    if useByteEncoding:
                        result.append(delta)
                    else:
                        result.append(delta >> 8)
                        result.append(delta & 0xFF)
                    lastValue = curValue
                    pos += 1
                    runLength += 1
                if useByteEncoding:
                    result[headerPos] = runLength - 1
                else:
                    result[headerPos] = (runLength - 1) | POINTS_ARE_WORDS

            return result

        @staticmethod
        def decompilePoints_(numPoints, data, offset, tableTag):
            """(numPoints, data, offset, tableTag) --> ([point1, point2, ...], newOffset)"""
            assert tableTag in ("cvar", "gvar")
            pos = offset
            numPointsInData = data[pos]
            pos += 1
            if (numPointsInData & POINTS_ARE_WORDS) != 0:
                numPointsInData = (numPointsInData & POINT_RUN_COUNT_MASK) << 8 | data[pos]
                pos += 1
            if numPointsInData == 0:
                return (range(numPoints), pos)

            result = []
            while len(result) < numPointsInData:
                runHeader = data[pos]
                pos += 1
                numPointsInRun = (runHeader & POINT_RUN_COUNT_MASK) + 1
                point = 0
                if (runHeader & POINTS_ARE_WORDS) != 0:
                    points = array.array("H")
                    pointsSize = numPointsInRun * 2
                else:
                    points = array.array("B")
                    pointsSize = numPointsInRun
                points.frombytes(data[pos : pos + pointsSize])
                if sys.byteorder != "big":
                    points.byteswap()

                assert len(points) == numPointsInRun
                pos += pointsSize

                result.extend(points)

            # Convert relative to absolute
            absolute = []
            current = 0
            for delta in result:
                current += delta
                absolute.append(current)
            result = absolute
            del absolute

            badPoints = {str(p) for p in result if p < 0 or p >= numPoints}
            if badPoints:
                log.warning(
                    "point %s out of range in '%s' table"
                    % (",".join(sorted(badPoints)), tableTag)
                )
            return (result, pos)

        def compileDeltas(self, optimizeSize=True):
            deltaX = []
            deltaY = []
            if self.getCoordWidth() == 2:
                for c in self.coordinates:
                    if c is None:
                        continue
                    deltaX.append(c[0])
                    deltaY.append(c[1])
            else:
                for c in self.coordinates:
                    if c is None:
                        continue
                    deltaX.append(c)
            bytearr = bytearray()
            self.compileDeltaValues_(deltaX, bytearr, optimizeSize=optimizeSize)
            self.compileDeltaValues_(deltaY, bytearr, optimizeSize=optimizeSize)
            return bytearr

        @staticmethod
        def compileDeltaValues_(deltas, bytearr=None, *, optimizeSize=True):
            """[value1, value2, value3, ...] --> bytearray

            Emits a sequence of runs. Each run starts with a
            byte-sized header whose 6 least significant bits
            (header & 0x3F) indicate how many values are encoded
            in this run. The stored length is the actual length
            minus one; run lengths are thus in the range [1..64].
            If the header byte has its most significant bit (0x80)
            set, all values in this run are zero, and no data
            follows. Otherwise, the header byte is followed by
            ((header & 0x3F) + 1) signed values.  If (header &
            0x40) is clear, the delta values are stored as signed
            bytes; if (header & 0x40) is set, the delta values are
            signed 16-bit integers.
            """  # Explaining the format because the 'gvar' spec is hard to understand.
            if bytearr is None:
                bytearr = bytearray()

            pos = 0
            numDeltas = len(deltas)

            if optimizeSize:
                while pos < numDeltas:
                    value = deltas[pos]
                    if value == 0:
                        pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr)
                    elif -128 <= value <= 127:
                        pos = TupleVariation.encodeDeltaRunAsBytes_(deltas, pos, bytearr)
                    elif -32768 <= value <= 32767:
                        pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, bytearr)
                    else:
                        pos = TupleVariation.encodeDeltaRunAsLongs_(deltas, pos, bytearr)
            else:
                minVal, maxVal = min(deltas), max(deltas)
                if minVal == 0 == maxVal:
                    pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr)
                elif -128 <= minVal <= maxVal <= 127:
                    pos = TupleVariation.encodeDeltaRunAsBytes_(
                        deltas, pos, bytearr, optimizeSize=False
                    )
                elif -32768 <= minVal <= maxVal <= 32767:
                    pos = TupleVariation.encodeDeltaRunAsWords_(
                        deltas, pos, bytearr, optimizeSize=False
                    )
                else:
                    pos = TupleVariation.encodeDeltaRunAsLongs_(
                        deltas, pos, bytearr, optimizeSize=False
                    )

            assert pos == numDeltas, (pos, numDeltas)

            return bytearr

        @staticmethod
        def encodeDeltaRunAsZeroes_(deltas, offset, bytearr):
            pos = offset
            numDeltas = len(deltas)
            while pos < numDeltas and deltas[pos] == 0:
                pos += 1
            runLength = pos - offset
            while runLength >= 64:
                bytearr.append(DELTAS_ARE_ZERO | 63)
                runLength -= 64
            if runLength:
                bytearr.append(DELTAS_ARE_ZERO | (runLength - 1))
            return pos

        @staticmethod
        def encodeDeltaRunAsBytes_(deltas, offset, bytearr, optimizeSize=True):
            pos = offset
            numDeltas = len(deltas)
            while pos < numDeltas:
                value = deltas[pos]
                if not (-128 <= value <= 127):
                    break
                # Within a byte-encoded run of deltas, a single zero
                # is best stored literally as 0x00 value. However,
                # if are two or more zeroes in a sequence, it is
                # better to start a new run. For example, the sequence
                # of deltas [15, 15, 0, 15, 15] becomes 6 bytes
                # (04 0F 0F 00 0F 0F) when storing the zero value
                # literally, but 7 bytes (01 0F 0F 80 01 0F 0F)
                # when starting a new run.
                if (
                    optimizeSize
                    and value == 0
                    and pos + 1 < numDeltas
                    and deltas[pos + 1] == 0
                ):
                    break
                pos += 1
            runLength = pos - offset
            while runLength >= 64:
                bytearr.append(63)
                bytearr.extend(array.array("b", deltas[offset : offset + 64]))
                offset += 64
                runLength -= 64
            if runLength:
                bytearr.append(runLength - 1)
                bytearr.extend(array.array("b", deltas[offset:pos]))
            return pos

        @staticmethod
        def encodeDeltaRunAsWords_(deltas, offset, bytearr, optimizeSize=True):
            pos = offset
            numDeltas = len(deltas)
            while pos < numDeltas:
                value = deltas[pos]

                # Within a word-encoded run of deltas, it is easiest
                # to start a new run (with a different encoding)
                # whenever we encounter a zero value. For example,
                # the sequence [0x6666, 0, 0x7777] needs 7 bytes when
                # storing the zero literally (42 66 66 00 00 77 77),
                # and equally 7 bytes when starting a new run
                # (40 66 66 80 40 77 77).
                if optimizeSize and value == 0:
                    break

                # Within a word-encoded run of deltas, a single value
                # in the range (-128..127) should be encoded literally
                # because it is more compact. For example, the sequence
                # [0x6666, 2, 0x7777] becomes 7 bytes when storing
                # the value literally (42 66 66 00 02 77 77), but 8 bytes
                # when starting a new run (40 66 66 00 02 40 77 77).
                if (
                    optimizeSize
                    and (-128 <= value <= 127)
                    and pos + 1 < numDeltas
                    and (-128 <= deltas[pos + 1] <= 127)
                ):
                    break

                if not (-32768 <= value <= 32767):
                    break

                pos += 1
            runLength = pos - offset
            while runLength >= 64:
                bytearr.append(DELTAS_ARE_WORDS | 63)
                a = array.array("h", deltas[offset : offset + 64])
                if sys.byteorder != "big":
                    a.byteswap()
                bytearr.extend(a)
                offset += 64
                runLength -= 64
            if runLength:
                bytearr.append(DELTAS_ARE_WORDS | (runLength - 1))
                a = array.array("h", deltas[offset:pos])
                if sys.byteorder != "big":
                    a.byteswap()
                bytearr.extend(a)
            return pos

        @staticmethod
        def encodeDeltaRunAsLongs_(deltas, offset, bytearr, optimizeSize=True):
            pos = offset
            numDeltas = len(deltas)
            while pos < numDeltas:
                value = deltas[pos]
                if optimizeSize and -32768 <= value <= 32767:
                    break
                pos += 1
            runLength = pos - offset
            while runLength >= 64:
                bytearr.append(DELTAS_ARE_LONGS | 63)
                a = array.array("i", deltas[offset : offset + 64])
                if sys.byteorder != "big":
                    a.byteswap()
                bytearr.extend(a)
                offset += 64
                runLength -= 64
            if runLength:
                bytearr.append(DELTAS_ARE_LONGS | (runLength - 1))
                a = array.array("i", deltas[offset:pos])
                if sys.byteorder != "big":
                    a.byteswap()
                bytearr.extend(a)
            return pos

        @staticmethod
        def decompileDeltas_(numDeltas, data, offset=0):
            """(numDeltas, data, offset) --> ([delta, delta, ...], newOffset)"""
            result = []
            pos = offset
            while len(result) < numDeltas if numDeltas is not None else pos < len(data):
                runHeader = data[pos]
                pos += 1
                numDeltasInRun = (runHeader & DELTA_RUN_COUNT_MASK) + 1
                if (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_ZERO:
                    result.extend([0] * numDeltasInRun)
                else:
                    if (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_LONGS:
                        deltas = array.array("i")
                        deltasSize = numDeltasInRun * 4
                    elif (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_WORDS:
                        deltas = array.array("h")
                        deltasSize = numDeltasInRun * 2
                    else:
                        deltas = array.array("b")
                        deltasSize = numDeltasInRun
                    deltas.frombytes(data[pos : pos + deltasSize])
                    if sys.byteorder != "big":
                        deltas.byteswap()
                    assert len(deltas) == numDeltasInRun, (len(deltas), numDeltasInRun)
                    pos += deltasSize
                    result.extend(deltas)
            assert numDeltas is None or len(result) == numDeltas
            return (result, pos)

        @staticmethod
        def getTupleSize_(flags, axisCount):
            size = 4
            if (flags & EMBEDDED_PEAK_TUPLE) != 0:
                size += axisCount * 2
            if (flags & INTERMEDIATE_REGION) != 0:
                size += axisCount * 4
            return size

        def getCoordWidth(self):
            """Return 2 if coordinates are (x, y) as in gvar, 1 if single values
            as in cvar, or 0 if empty.
            """
            firstDelta = next((c for c in self.coordinates if c is not None), None)
            if firstDelta is None:
                return 0  # empty or has no impact
            if type(firstDelta) in (int, float):
                return 1
            if type(firstDelta) is tuple and len(firstDelta) == 2:
                return 2
            raise TypeError(
                "invalid type of delta; expected (int or float) number, or "
                "Tuple[number, number]: %r" % firstDelta
            )

        def scaleDeltas(self, scalar):
            if scalar == 1.0:
                return  # no change
            coordWidth = self.getCoordWidth()
            self.coordinates = [
                (
                    None
                    if d is None
                    else d * scalar if coordWidth == 1 else (d[0] * scalar, d[1] * scalar)
                )
                for d in self.coordinates
            ]

        def roundDeltas(self):
            coordWidth = self.getCoordWidth()
            self.coordinates = [
                (
                    None
                    if d is None
                    else otRound(d) if coordWidth == 1 else (otRound(d[0]), otRound(d[1]))
                )
                for d in self.coordinates
            ]

        def calcInferredDeltas(self, origCoords, endPts):
            from fontTools.varLib.iup import iup_delta

            if self.getCoordWidth() == 1:
                raise TypeError("Only 'gvar' TupleVariation can have inferred deltas")
            if None in self.coordinates:
                if len(self.coordinates) != len(origCoords):
                    raise ValueError(
                        "Expected len(origCoords) == %d; found %d"
                        % (len(self.coordinates), len(origCoords))
                    )
                self.coordinates = iup_delta(self.coordinates, origCoords, endPts)

        def optimize(self, origCoords, endPts, tolerance=0.5, isComposite=False):
            from fontTools.varLib.iup import iup_delta_optimize

            if None in self.coordinates:
                return  # already optimized

            deltaOpt = iup_delta_optimize(
                self.coordinates, origCoords, endPts, tolerance=tolerance
            )
            if None in deltaOpt:
                if isComposite and all(d is None for d in deltaOpt):
                    # Fix for macOS composites
                    # https://github.com/fonttools/fonttools/issues/1381
                    deltaOpt = [(0, 0)] + [None] * (len(deltaOpt) - 1)
                # Use "optimized" version only if smaller...
                varOpt = TupleVariation(self.axes, deltaOpt)

                # Shouldn't matter that this is different from fvar...?
                axisTags = sorted(self.axes.keys())
                tupleData, auxData = self.compile(axisTags)
                unoptimizedLength = len(tupleData) + len(auxData)
                tupleData, auxData = varOpt.compile(axisTags)
                optimizedLength = len(tupleData) + len(auxData)

                if optimizedLength < unoptimizedLength:
                    self.coordinates = varOpt.coordinates

        def __imul__(self, scalar):
            self.scaleDeltas(scalar)
            return self

        def __iadd__(self, other):
            if not isinstance(other, TupleVariation):
                return NotImplemented
            deltas1 = self.coordinates
            length = len(deltas1)
            deltas2 = other.coordinates
            if len(deltas2) != length:
                raise ValueError("cannot sum TupleVariation deltas with different lengths")
            # 'None' values have different meanings in gvar vs cvar TupleVariations:
            # within the gvar, when deltas are not provided explicitly for some points,
            # they need to be inferred; whereas for the 'cvar' table, if deltas are not
            # provided for some CVT values, then no adjustments are made (i.e. None == 0).
            # Thus, we cannot sum deltas for gvar TupleVariations if they contain
            # inferred inferred deltas (the latter need to be computed first using
            # 'calcInferredDeltas' method), but we can treat 'None' values in cvar
            # deltas as if they are zeros.
            if self.getCoordWidth() == 2:
                for i, d2 in zip(range(length), deltas2):
                    d1 = deltas1[i]
                    try:
                        deltas1[i] = (d1[0] + d2[0], d1[1] + d2[1])
                    except TypeError:
                        raise ValueError("cannot sum gvar deltas with inferred points")
            else:
                for i, d2 in zip(range(length), deltas2):
                    d1 = deltas1[i]
                    if d1 is not None and d2 is not None:
                        deltas1[i] = d1 + d2
                    elif d1 is None and d2 is not None:
                        deltas1[i] = d2
                    # elif d2 is None do nothing
            return self

    def decompileSharedTuples(axisTags, sharedTupleCount, data, offset):
        result = []
        for _ in range(sharedTupleCount):
            t, offset = TupleVariation.decompileCoord_(axisTags, data, offset)
            result.append(t)
        return result

    def compileSharedTuples(
        axisTags, variations, MAX_NUM_SHARED_COORDS=TUPLE_INDEX_MASK + 1
    ):
        coordCount = Counter()
        for var in variations:
            coord = var.compileCoord(axisTags)
            coordCount[coord] += 1
        # In python < 3.7, most_common() ordering is non-deterministic
        # so apply a sort to make sure the ordering is consistent.
        sharedCoords = sorted(
            coordCount.most_common(MAX_NUM_SHARED_COORDS),
            key=lambda item: (-item[1], item[0]),
        )
        return [c[0] for c in sharedCoords if c[1] > 1]

    def compileTupleVariationStore(
        variations,
        pointCount,
        axisTags,
        sharedTupleIndices,
        useSharedPoints=True,
        *,
        optimizeSize=True,
    ):
        # pointCount is actually unused. Keeping for API compat.
        del pointCount
        newVariations = []
        pointDatas = []
        # Compile all points and figure out sharing if desired
        sharedPoints = None

        # Collect, count, and compile point-sets for all variation sets
        pointSetCount = defaultdict(int)
        for v in variations:
            points = v.getUsedPoints()
            if points is None:  # Empty variations
                continue
            pointSetCount[points] += 1
            newVariations.append(v)
            pointDatas.append(points)
        variations = newVariations
        del newVariations

        if not variations:
            return (0, b"", b"")

        n = len(variations[0].coordinates)
        assert all(
            len(v.coordinates) == n for v in variations
        ), "Variation sets have different sizes"

        compiledPoints = {
            pointSet: TupleVariation.compilePoints(pointSet) for pointSet in pointSetCount
        }

        tupleVariationCount = len(variations)
        tuples = []
        data = []

        if useSharedPoints:
            # Find point-set which saves most bytes.
            def key(pn):
                pointSet = pn[0]
                count = pn[1]
                return len(compiledPoints[pointSet]) * (count - 1)

            sharedPoints = max(pointSetCount.items(), key=key)[0]

            data.append(compiledPoints[sharedPoints])
            tupleVariationCount |= TUPLES_SHARE_POINT_NUMBERS

        # b'' implies "use shared points"
        pointDatas = [
            compiledPoints[points] if points != sharedPoints else b""
            for points in pointDatas
        ]

        for v, p in zip(variations, pointDatas):
            thisTuple, thisData = v.compile(
                axisTags, sharedTupleIndices, pointData=p, optimizeSize=optimizeSize
            )

            tuples.append(thisTuple)
            data.append(thisData)

        tuples = b"".join(tuples)
        data = b"".join(data)
        return tupleVariationCount, tuples, data

    def decompileTupleVariationStore(
        tableTag,
        axisTags,
        tupleVariationCount,
        pointCount,
        sharedTuples,
        data,
        pos,
        dataPos,
    ):
        numAxes = len(axisTags)
        result = []
        if (tupleVariationCount & TUPLES_SHARE_POINT_NUMBERS) != 0:
            sharedPoints, dataPos = TupleVariation.decompilePoints_(
                pointCount, data, dataPos, tableTag
            )
        else:
            sharedPoints = []
        for _ in range(tupleVariationCount & TUPLE_COUNT_MASK):
            dataSize, flags = struct.unpack(">HH", data[pos : pos + 4])
            tupleSize = TupleVariation.getTupleSize_(flags, numAxes)
            tupleData = data[pos : pos + tupleSize]
            pointDeltaData = data[dataPos : dataPos + dataSize]
            result.append(
                decompileTupleVariation_(
                    pointCount,
                    sharedTuples,
                    sharedPoints,
                    tableTag,
                    axisTags,
                    tupleData,
                    pointDeltaData,
                )
            )
            pos += tupleSize
            dataPos += dataSize
        return result

    def decompileTupleVariation_(
        pointCount, sharedTuples, sharedPoints, tableTag, axisTags, data, tupleData
    ):
        assert tableTag in ("cvar", "gvar"), tableTag
        flags = struct.unpack(">H", data[2:4])[0]
        pos = 4
        if (flags & EMBEDDED_PEAK_TUPLE) == 0:
            peak = sharedTuples[flags & TUPLE_INDEX_MASK]
        else:
            peak, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
        if (flags & INTERMEDIATE_REGION) != 0:
            start, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
            end, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
        else:
            start, end = inferRegion_(peak)
        axes = {}
        for axis in axisTags:
            region = start[axis], peak[axis], end[axis]
            if region != (0.0, 0.0, 0.0):
                axes[axis] = region
        pos = 0
        if (flags & PRIVATE_POINT_NUMBERS) != 0:
            points, pos = TupleVariation.decompilePoints_(
                pointCount, tupleData, pos, tableTag
            )
        else:
            points = sharedPoints

        deltas = [None] * pointCount

        if tableTag == "cvar":
            deltas_cvt, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
            for p, delta in zip(points, deltas_cvt):
                if 0 <= p < pointCount:
                    deltas[p] = delta

        elif tableTag == "gvar":
            deltas_x, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
            deltas_y, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
            for p, x, y in zip(points, deltas_x, deltas_y):
                if 0 <= p < pointCount:
                    deltas[p] = (x, y)

        return TupleVariation(axes, deltas)

    def inferRegion_(peak):
        """Infer start and end for a (non-intermediate) region

        This helper function computes the applicability region for
        variation tuples whose INTERMEDIATE_REGION flag is not set in the
        TupleVariationHeader structure.  Variation tuples apply only to
        certain regions of the variation space; outside that region, the
        tuple has no effect.  To make the binary encoding more compact,
        TupleVariationHeaders can omit the intermediateStartTuple and
        intermediateEndTuple fields.
        """
        start, end = {}, {}
        for axis, value in peak.items():
            start[axis] = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
            end[axis] = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
        return (start, end)