# 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
    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):
    		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())
    		auxData = b''.join(auxData)

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

    	def compileCoord(self, axisTags):
    		result = bytearray()
    		axes = self.axes
    		for axis in axisTags:
    			triple = axes.get(axis)
    			if triple is None:
    				result.extend(b'\0\0')
    			else:
    				result.extend(struct.pack(">h", fl2fi(triple[1], 14)))
    		return bytes(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 = bytearray()
    		maxCoords = bytearray()
    		for axis in axisTags:
    			minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
    			minCoords.extend(struct.pack(">h", fl2fi(minValue, 14)))
    			maxCoords.extend(struct.pack(">h", fl2fi(maxValue, 14)))
    		return 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):
    		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)
    		self.compileDeltaValues_(deltaY, bytearr)
    		return bytearr

    	@staticmethod
    	def compileDeltaValues_(deltas, bytearr=None):
    		"""[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)
    		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)
    			else:
    				pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, bytearr)
    		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):
    		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 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):
    		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 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 (-128 <= value <= 127) and pos+1 < numDeltas and (-128 <= deltas[pos+1] <= 127):
    				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 decompileDeltas_(numDeltas, data, offset):
    		"""(numDeltas, data, offset) --> ([delta, delta, ...], newOffset)"""
    		result = []
    		pos = offset
    		while len(result) < numDeltas:
    			runHeader = data[pos]
    			pos += 1
    			numDeltasInRun = (runHeader & DELTA_RUN_COUNT_MASK) + 1
    			if (runHeader & DELTAS_ARE_ZERO) != 0:
    				result.extend([0] * numDeltasInRun)
    			else:
    				if (runHeader & DELTAS_ARE_WORDS) != 0:
    					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
    				pos += deltasSize
    				result.extend(deltas)
    		assert 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 __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):
    	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)

    		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)