# Source code for fontTools.ttLib.tables._g_l_y_f

    """_g_l_y_f.py -- Converter classes for the 'glyf' table."""

    from collections import namedtuple
    from fontTools.misc import sstruct
    from fontTools import ttLib
    from fontTools import version
    from fontTools.misc.transform import DecomposedTransform
    from fontTools.misc.textTools import tostr, safeEval, pad
    from fontTools.misc.arrayTools import updateBounds, pointInRect
    from fontTools.misc.bezierTools import calcQuadraticBounds
    from fontTools.misc.fixedTools import (
        fixedToFloat as fi2fl,
        floatToFixed as fl2fi,
        floatToFixedToStr as fl2str,
        strToFixedToFloat as str2fl,
    )
    from fontTools.misc.roundTools import noRound, otRound
    from fontTools.misc.vector import Vector
    from numbers import Number
    from . import DefaultTable
    from . import ttProgram
    import sys
    import struct
    import array
    import logging
    import math
    import os
    from fontTools.misc import xmlWriter
    from fontTools.misc.filenames import userNameToFileName
    from fontTools.misc.loggingTools import deprecateFunction
    from enum import IntFlag
    from functools import partial
    from types import SimpleNamespace
    from typing import Set

    log = logging.getLogger(__name__)

    # We compute the version the same as is computed in ttlib/__init__
    # so that we can write 'ttLibVersion' attribute of the glyf TTX files
    # when glyf is written to separate files.
    version = ".".join(version.split(".")[:2])

    #
    # The Apple and MS rasterizers behave differently for
    # scaled composite components: one does scale first and then translate
    # and the other does it vice versa. MS defined some flags to indicate
    # the difference, but it seems nobody actually _sets_ those flags.
    #
    # Funny thing: Apple seems to _only_ do their thing in the
    # WE_HAVE_A_SCALE (eg. Chicago) case, and not when it's WE_HAVE_AN_X_AND_Y_SCALE
    # (eg. Charcoal)...
    #
    SCALE_COMPONENT_OFFSET_DEFAULT = 0  # 0 == MS, 1 == Apple

    class table__g_l_y_f(DefaultTable.DefaultTable):
        """Glyph Data table

        This class represents the `glyf <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf>`_
        table, which contains outlines for glyphs in TrueType format. In many cases,
        it is easier to access and manipulate glyph outlines through the ``GlyphSet``
        object returned from :py:meth:`fontTools.ttLib.ttFont.getGlyphSet`::

                        >> from fontTools.pens.boundsPen import BoundsPen
                        >> glyphset = font.getGlyphSet()
                        >> bp = BoundsPen(glyphset)
                        >> glyphset["A"].draw(bp)
                        >> bp.bounds
                        (19, 0, 633, 716)

        However, this class can be used for low-level access to the ``glyf`` table data.
        Objects of this class support dictionary-like access, mapping glyph names to
        :py:class:`Glyph` objects::

                        >> glyf = font["glyf"]
                        >> len(glyf["Aacute"].components)
                        2

        Note that when adding glyphs to the font via low-level access to the ``glyf``
        table, the new glyphs must also be added to the ``hmtx``/``vmtx`` table::

                        >> font["glyf"]["divisionslash"] = Glyph()
                        >> font["hmtx"]["divisionslash"] = (640, 0)

        """

        dependencies = ["fvar"]

        # this attribute controls the amount of padding applied to glyph data upon compile.
        # Glyph lenghts are aligned to multiples of the specified value.
        # Allowed values are (0, 1, 2, 4). '0' means no padding; '1' (default) also means
        # no padding, except for when padding would allow to use short loca offsets.
        padding = 1

        def decompile(self, data, ttFont):
            self.axisTags = (
                [axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
            )
            loca = ttFont["loca"]
            pos = int(loca[0])
            nextPos = 0
            noname = 0
            self.glyphs = {}
            self.glyphOrder = glyphOrder = ttFont.getGlyphOrder()
            self._reverseGlyphOrder = {}
            for i in range(0, len(loca) - 1):
                try:
                    glyphName = glyphOrder[i]
                except IndexError:
                    noname = noname + 1
                    glyphName = "ttxautoglyph%s" % i
                nextPos = int(loca[i + 1])
                glyphdata = data[pos:nextPos]
                if len(glyphdata) != (nextPos - pos):
                    raise ttLib.TTLibError("not enough 'glyf' table data")
                glyph = Glyph(glyphdata)
                self.glyphs[glyphName] = glyph
                pos = nextPos
            if len(data) - nextPos >= 4:
                log.warning(
                    "too much 'glyf' table data: expected %d, received %d bytes",
                    nextPos,
                    len(data),
                )
            if noname:
                log.warning("%s glyphs have no name", noname)
            if ttFont.lazy is False:  # Be lazy for None and True
                self.ensureDecompiled()

        def ensureDecompiled(self, recurse=False):
            # The recurse argument is unused, but part of the signature of
            # ensureDecompiled across the library.
            for glyph in self.glyphs.values():
                glyph.expand(self)

        def compile(self, ttFont):
            optimizeSpeed = ttFont.cfg[ttLib.OPTIMIZE_FONT_SPEED]

            self.axisTags = (
                [axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
            )
            if not hasattr(self, "glyphOrder"):
                self.glyphOrder = ttFont.getGlyphOrder()
            padding = self.padding
            assert padding in (0, 1, 2, 4)
            locations = []
            currentLocation = 0
            dataList = []
            recalcBBoxes = ttFont.recalcBBoxes
            boundsDone = set()
            for glyphName in self.glyphOrder:
                glyph = self.glyphs[glyphName]
                glyphData = glyph.compile(
                    self,
                    recalcBBoxes,
                    boundsDone=boundsDone,
                    optimizeSize=not optimizeSpeed,
                )
                if padding > 1:
                    glyphData = pad(glyphData, size=padding)
                locations.append(currentLocation)
                currentLocation = currentLocation + len(glyphData)
                dataList.append(glyphData)
            locations.append(currentLocation)

            if padding == 1 and currentLocation < 0x20000:
                # See if we can pad any odd-lengthed glyphs to allow loca
                # table to use the short offsets.
                indices = [
                    i for i, glyphData in enumerate(dataList) if len(glyphData) % 2 == 1
                ]
                if indices and currentLocation + len(indices) < 0x20000:
                    # It fits.  Do it.
                    for i in indices:
                        dataList[i] += b"\0"
                    currentLocation = 0
                    for i, glyphData in enumerate(dataList):
                        locations[i] = currentLocation
                        currentLocation += len(glyphData)
                    locations[len(dataList)] = currentLocation

            data = b"".join(dataList)
            if "loca" in ttFont:
                ttFont["loca"].set(locations)
            if "maxp" in ttFont:
                ttFont["maxp"].numGlyphs = len(self.glyphs)
            if not data:
                # As a special case when all glyph in the font are empty, add a zero byte
                # to the table, so that OTS doesn’t reject it, and to make the table work
                # on Windows as well.
                # See https://github.com/khaledhosny/ots/issues/52
                data = b"\0"
            return data

        def toXML(self, writer, ttFont, splitGlyphs=False):
            notice = (
                "The xMin, yMin, xMax and yMax values\n"
                "will be recalculated by the compiler."
            )
            glyphNames = ttFont.getGlyphNames()
            if not splitGlyphs:
                writer.newline()
                writer.comment(notice)
                writer.newline()
                writer.newline()
            numGlyphs = len(glyphNames)
            if splitGlyphs:
                path, ext = os.path.splitext(writer.file.name)
                existingGlyphFiles = set()
            for glyphName in glyphNames:
                glyph = self.get(glyphName)
                if glyph is None:
                    log.warning("glyph '%s' does not exist in glyf table", glyphName)
                    continue
                if glyph.numberOfContours:
                    if splitGlyphs:
                        glyphPath = userNameToFileName(
                            tostr(glyphName, "utf-8"),
                            existingGlyphFiles,
                            prefix=path + ".",
                            suffix=ext,
                        )
                        existingGlyphFiles.add(glyphPath.lower())
                        glyphWriter = xmlWriter.XMLWriter(
                            glyphPath,
                            idlefunc=writer.idlefunc,
                            newlinestr=writer.newlinestr,
                        )
                        glyphWriter.begintag("ttFont", ttLibVersion=version)
                        glyphWriter.newline()
                        glyphWriter.begintag("glyf")
                        glyphWriter.newline()
                        glyphWriter.comment(notice)
                        glyphWriter.newline()
                        writer.simpletag("TTGlyph", src=os.path.basename(glyphPath))
                    else:
                        glyphWriter = writer
                    glyphWriter.begintag(
                        "TTGlyph",
                        [
                            ("name", glyphName),
                            ("xMin", glyph.xMin),
                            ("yMin", glyph.yMin),
                            ("xMax", glyph.xMax),
                            ("yMax", glyph.yMax),
                        ],
                    )
                    glyphWriter.newline()
                    glyph.toXML(glyphWriter, ttFont)
                    glyphWriter.endtag("TTGlyph")
                    glyphWriter.newline()
                    if splitGlyphs:
                        glyphWriter.endtag("glyf")
                        glyphWriter.newline()
                        glyphWriter.endtag("ttFont")
                        glyphWriter.newline()
                        glyphWriter.close()
                else:
                    writer.simpletag("TTGlyph", name=glyphName)
                    writer.comment("contains no outline data")
                    if not splitGlyphs:
                        writer.newline()
                writer.newline()

        def fromXML(self, name, attrs, content, ttFont):
            if name != "TTGlyph":
                return
            if not hasattr(self, "glyphs"):
                self.glyphs = {}
            if not hasattr(self, "glyphOrder"):
                self.glyphOrder = ttFont.getGlyphOrder()
            glyphName = attrs["name"]
            log.debug("unpacking glyph '%s'", glyphName)
            glyph = Glyph()
            for attr in ["xMin", "yMin", "xMax", "yMax"]:
                setattr(glyph, attr, safeEval(attrs.get(attr, "0")))
            self.glyphs[glyphName] = glyph
            for element in content:
                if not isinstance(element, tuple):
                    continue
                name, attrs, content = element
                glyph.fromXML(name, attrs, content, ttFont)
            if not ttFont.recalcBBoxes:
                glyph.compact(self, 0)

        def setGlyphOrder(self, glyphOrder):
            """Sets the glyph order

            Args:
                    glyphOrder ([str]): List of glyph names in order.
            """
            self.glyphOrder = glyphOrder
            self._reverseGlyphOrder = {}

        def getGlyphName(self, glyphID):
            """Returns the name for the glyph with the given ID.

            Raises a ``KeyError`` if the glyph name is not found in the font.
            """
            return self.glyphOrder[glyphID]

        def _buildReverseGlyphOrderDict(self):
            self._reverseGlyphOrder = d = {}
            for glyphID, glyphName in enumerate(self.glyphOrder):
                d[glyphName] = glyphID

        def getGlyphID(self, glyphName):
            """Returns the ID of the glyph with the given name.

            Raises a ``ValueError`` if the glyph is not found in the font.
            """
            glyphOrder = self.glyphOrder
            id = getattr(self, "_reverseGlyphOrder", {}).get(glyphName)
            if id is None or id >= len(glyphOrder) or glyphOrder[id] != glyphName:
                self._buildReverseGlyphOrderDict()
                id = self._reverseGlyphOrder.get(glyphName)
            if id is None:
                raise ValueError(glyphName)
            return id

        def removeHinting(self):
            """Removes TrueType hints from all glyphs in the glyphset.

            See :py:meth:`Glyph.removeHinting`.
            """
            for glyph in self.glyphs.values():
                glyph.removeHinting()

        def keys(self):
            return self.glyphs.keys()

        def has_key(self, glyphName):
            return glyphName in self.glyphs

        __contains__ = has_key

        def get(self, glyphName, default=None):
            glyph = self.glyphs.get(glyphName, default)
            if glyph is not None:
                glyph.expand(self)
            return glyph

        def __getitem__(self, glyphName):
            glyph = self.glyphs[glyphName]
            glyph.expand(self)
            return glyph

        def __setitem__(self, glyphName, glyph):
            self.glyphs[glyphName] = glyph
            if glyphName not in self.glyphOrder:
                self.glyphOrder.append(glyphName)

        def __delitem__(self, glyphName):
            del self.glyphs[glyphName]
            self.glyphOrder.remove(glyphName)

        def __len__(self):
            assert len(self.glyphOrder) == len(self.glyphs)
            return len(self.glyphs)

        def _getPhantomPoints(self, glyphName, hMetrics, vMetrics=None):
            """Compute the four "phantom points" for the given glyph from its bounding box
            and the horizontal and vertical advance widths and sidebearings stored in the
            ttFont's "hmtx" and "vmtx" tables.

            'hMetrics' should be ttFont['hmtx'].metrics.

            'vMetrics' should be ttFont['vmtx'].metrics if there is "vmtx" or None otherwise.
            If there is no vMetrics passed in, vertical phantom points are set to the zero coordinate.

            https://docs.microsoft.com/en-us/typography/opentype/spec/tt_instructing_glyphs#phantoms
            """
            glyph = self[glyphName]
            if not hasattr(glyph, "xMin"):
                glyph.recalcBounds(self)

            horizontalAdvanceWidth, leftSideBearing = hMetrics[glyphName]
            leftSideX = glyph.xMin - leftSideBearing
            rightSideX = leftSideX + horizontalAdvanceWidth

            if vMetrics:
                verticalAdvanceWidth, topSideBearing = vMetrics[glyphName]
                topSideY = topSideBearing + glyph.yMax
                bottomSideY = topSideY - verticalAdvanceWidth
            else:
                bottomSideY = topSideY = 0

            return [
                (leftSideX, 0),
                (rightSideX, 0),
                (0, topSideY),
                (0, bottomSideY),
            ]

        def _getCoordinatesAndControls(
            self, glyphName, hMetrics, vMetrics=None, *, round=otRound
        ):
            """Return glyph coordinates and controls as expected by "gvar" table.

            The coordinates includes four "phantom points" for the glyph metrics,
            as mandated by the "gvar" spec.

            The glyph controls is a namedtuple with the following attributes:
                    - numberOfContours: -1 for composite glyphs.
                    - endPts: list of indices of end points for each contour in simple
                    glyphs, or component indices in composite glyphs (used for IUP
                    optimization).
                    - flags: array of contour point flags for simple glyphs (None for
                    composite glyphs).
                    - components: list of base glyph names (str) for each component in
                    composite glyphs (None for simple glyphs).

            The "hMetrics" and vMetrics are used to compute the "phantom points" (see
            the "_getPhantomPoints" method).

            Return None if the requested glyphName is not present.
            """
            glyph = self.get(glyphName)
            if glyph is None:
                return None
            if glyph.isComposite():
                coords = GlyphCoordinates(
                    [(getattr(c, "x", 0), getattr(c, "y", 0)) for c in glyph.components]
                )
                controls = _GlyphControls(
                    numberOfContours=glyph.numberOfContours,
                    endPts=list(range(len(glyph.components))),
                    flags=None,
                    components=[
                        (c.glyphName, getattr(c, "transform", None))
                        for c in glyph.components
                    ],
                )
            else:
                coords, endPts, flags = glyph.getCoordinates(self)
                coords = coords.copy()
                controls = _GlyphControls(
                    numberOfContours=glyph.numberOfContours,
                    endPts=endPts,
                    flags=flags,
                    components=None,
                )
            # Add phantom points for (left, right, top, bottom) positions.
            phantomPoints = self._getPhantomPoints(glyphName, hMetrics, vMetrics)
            coords.extend(phantomPoints)
            coords.toInt(round=round)
            return coords, controls

        def _setCoordinates(self, glyphName, coord, hMetrics, vMetrics=None):
            """Set coordinates and metrics for the given glyph.

            "coord" is an array of GlyphCoordinates which must include the "phantom
            points" as the last four coordinates.

            Both the horizontal/vertical advances and left/top sidebearings in "hmtx"
            and "vmtx" tables (if any) are updated from four phantom points and
            the glyph's bounding boxes.

            The "hMetrics" and vMetrics are used to propagate "phantom points"
            into "hmtx" and "vmtx" tables if desired.  (see the "_getPhantomPoints"
            method).
            """
            glyph = self[glyphName]

            # Handle phantom points for (left, right, top, bottom) positions.
            assert len(coord) >= 4
            leftSideX = coord[-4][0]
            rightSideX = coord[-3][0]
            topSideY = coord[-2][1]
            bottomSideY = coord[-1][1]

            coord = coord[:-4]

            if glyph.isComposite():
                assert len(coord) == len(glyph.components)
                for p, comp in zip(coord, glyph.components):
                    if hasattr(comp, "x"):
                        comp.x, comp.y = p
            elif glyph.numberOfContours == 0:
                assert len(coord) == 0
            else:
                assert len(coord) == len(glyph.coordinates)
                glyph.coordinates = GlyphCoordinates(coord)

            glyph.recalcBounds(self, boundsDone=set())

            horizontalAdvanceWidth = otRound(rightSideX - leftSideX)
            if horizontalAdvanceWidth < 0:
                # unlikely, but it can happen, see:
                # https://github.com/fonttools/fonttools/pull/1198
                horizontalAdvanceWidth = 0
            leftSideBearing = otRound(glyph.xMin - leftSideX)
            hMetrics[glyphName] = horizontalAdvanceWidth, leftSideBearing

            if vMetrics is not None:
                verticalAdvanceWidth = otRound(topSideY - bottomSideY)
                if verticalAdvanceWidth < 0:  # unlikely but do the same as horizontal
                    verticalAdvanceWidth = 0
                topSideBearing = otRound(topSideY - glyph.yMax)
                vMetrics[glyphName] = verticalAdvanceWidth, topSideBearing

        # Deprecated

        def _synthesizeVMetrics(self, glyphName, ttFont, defaultVerticalOrigin):
            """This method is wrong and deprecated.
            For rationale see:
            https://github.com/fonttools/fonttools/pull/2266/files#r613569473
            """
            vMetrics = getattr(ttFont.get("vmtx"), "metrics", None)
            if vMetrics is None:
                verticalAdvanceWidth = ttFont["head"].unitsPerEm
                topSideY = getattr(ttFont.get("hhea"), "ascent", None)
                if topSideY is None:
                    if defaultVerticalOrigin is not None:
                        topSideY = defaultVerticalOrigin
                    else:
                        topSideY = verticalAdvanceWidth
                glyph = self[glyphName]
                glyph.recalcBounds(self)
                topSideBearing = otRound(topSideY - glyph.yMax)
                vMetrics = {glyphName: (verticalAdvanceWidth, topSideBearing)}
            return vMetrics

        @deprecateFunction("use '_getPhantomPoints' instead", category=DeprecationWarning)
        def getPhantomPoints(self, glyphName, ttFont, defaultVerticalOrigin=None):
            """Old public name for self._getPhantomPoints().
            See: https://github.com/fonttools/fonttools/pull/2266"""
            hMetrics = ttFont["hmtx"].metrics
            vMetrics = self._synthesizeVMetrics(glyphName, ttFont, defaultVerticalOrigin)
            return self._getPhantomPoints(glyphName, hMetrics, vMetrics)

        @deprecateFunction(
            "use '_getCoordinatesAndControls' instead", category=DeprecationWarning
        )
        def getCoordinatesAndControls(self, glyphName, ttFont, defaultVerticalOrigin=None):
            """Old public name for self._getCoordinatesAndControls().
            See: https://github.com/fonttools/fonttools/pull/2266"""
            hMetrics = ttFont["hmtx"].metrics
            vMetrics = self._synthesizeVMetrics(glyphName, ttFont, defaultVerticalOrigin)
            return self._getCoordinatesAndControls(glyphName, hMetrics, vMetrics)

        @deprecateFunction("use '_setCoordinates' instead", category=DeprecationWarning)
        def setCoordinates(self, glyphName, ttFont):
            """Old public name for self._setCoordinates().
            See: https://github.com/fonttools/fonttools/pull/2266"""
            hMetrics = ttFont["hmtx"].metrics
            vMetrics = getattr(ttFont.get("vmtx"), "metrics", None)
            self._setCoordinates(glyphName, hMetrics, vMetrics)

    _GlyphControls = namedtuple(
        "_GlyphControls", "numberOfContours endPts flags components"
    )

    glyphHeaderFormat = """
    		>	# big endian
    		numberOfContours:	h
    		xMin:				h
    		yMin:				h
    		xMax:				h
    		yMax:				h
    """

    # flags
    flagOnCurve = 0x01
    flagXShort = 0x02
    flagYShort = 0x04
    flagRepeat = 0x08
    flagXsame = 0x10
    flagYsame = 0x20
    flagOverlapSimple = 0x40
    flagCubic = 0x80

    # These flags are kept for XML output after decompiling the coordinates
    keepFlags = flagOnCurve + flagOverlapSimple + flagCubic

    _flagSignBytes = {
        0: 2,
        flagXsame: 0,
        flagXShort | flagXsame: +1,
        flagXShort: -1,
        flagYsame: 0,
        flagYShort | flagYsame: +1,
        flagYShort: -1,
    }

    def flagBest(x, y, onCurve):
        """For a given x,y delta pair, returns the flag that packs this pair
        most efficiently, as well as the number of byte cost of such flag."""

        flag = flagOnCurve if onCurve else 0
        cost = 0
        # do x
        if x == 0:
            flag = flag | flagXsame
        elif -255 <= x <= 255:
            flag = flag | flagXShort
            if x > 0:
                flag = flag | flagXsame
            cost += 1
        else:
            cost += 2
        # do y
        if y == 0:
            flag = flag | flagYsame
        elif -255 <= y <= 255:
            flag = flag | flagYShort
            if y > 0:
                flag = flag | flagYsame
            cost += 1
        else:
            cost += 2
        return flag, cost

    def flagFits(newFlag, oldFlag, mask):
        newBytes = _flagSignBytes[newFlag & mask]
        oldBytes = _flagSignBytes[oldFlag & mask]
        return newBytes == oldBytes or abs(newBytes) > abs(oldBytes)

    def flagSupports(newFlag, oldFlag):
        return (
            (oldFlag & flagOnCurve) == (newFlag & flagOnCurve)
            and flagFits(newFlag, oldFlag, flagXsame | flagXShort)
            and flagFits(newFlag, oldFlag, flagYsame | flagYShort)
        )

    def flagEncodeCoord(flag, mask, coord, coordBytes):
        byteCount = _flagSignBytes[flag & mask]
        if byteCount == 1:
            coordBytes.append(coord)
        elif byteCount == -1:
            coordBytes.append(-coord)
        elif byteCount == 2:
            coordBytes.extend(struct.pack(">h", coord))

    def flagEncodeCoords(flag, x, y, xBytes, yBytes):
        flagEncodeCoord(flag, flagXsame | flagXShort, x, xBytes)
        flagEncodeCoord(flag, flagYsame | flagYShort, y, yBytes)

    ARG_1_AND_2_ARE_WORDS = 0x0001  # if set args are words otherwise they are bytes
    ARGS_ARE_XY_VALUES = 0x0002  # if set args are xy values, otherwise they are points
    ROUND_XY_TO_GRID = 0x0004  # for the xy values if above is true
    WE_HAVE_A_SCALE = 0x0008  # Sx = Sy, otherwise scale == 1.0
    NON_OVERLAPPING = 0x0010  # set to same value for all components (obsolete!)
    MORE_COMPONENTS = 0x0020  # indicates at least one more glyph after this one
    WE_HAVE_AN_X_AND_Y_SCALE = 0x0040  # Sx, Sy
    WE_HAVE_A_TWO_BY_TWO = 0x0080  # t00, t01, t10, t11
    WE_HAVE_INSTRUCTIONS = 0x0100  # instructions follow
    USE_MY_METRICS = 0x0200  # apply these metrics to parent glyph
    OVERLAP_COMPOUND = 0x0400  # used by Apple in GX fonts
    SCALED_COMPONENT_OFFSET = 0x0800  # composite designed to have the component offset scaled (designed for Apple)
    UNSCALED_COMPONENT_OFFSET = 0x1000  # composite designed not to have the component offset scaled (designed for MS)

    CompositeMaxpValues = namedtuple(
        "CompositeMaxpValues", ["nPoints", "nContours", "maxComponentDepth"]
    )

    class Glyph(object):
        """This class represents an individual TrueType glyph.

        TrueType glyph objects come in two flavours: simple and composite. Simple
        glyph objects contain contours, represented via the ``.coordinates``,
        ``.flags``, ``.numberOfContours``, and ``.endPtsOfContours`` attributes;
        composite glyphs contain components, available through the ``.components``
        attributes.

        Because the ``.coordinates`` attribute (and other simple glyph attributes mentioned
        above) is only set on simple glyphs and the ``.components`` attribute is only
        set on composite glyphs, it is necessary to use the :py:meth:`isComposite`
        method to test whether a glyph is simple or composite before attempting to
        access its data.

        For a composite glyph, the components can also be accessed via array-like access::

                >> assert(font["glyf"]["Aacute"].isComposite())
                >> font["glyf"]["Aacute"][0]
                <fontTools.ttLib.tables._g_l_y_f.GlyphComponent at 0x1027b2ee0>

        """

        def __init__(self, data=b""):
            if not data:
                # empty char
                self.numberOfContours = 0
                return
            self.data = data

        def compact(self, glyfTable, recalcBBoxes=True):
            data = self.compile(glyfTable, recalcBBoxes)
            self.__dict__.clear()
            self.data = data

        def expand(self, glyfTable):
            if not hasattr(self, "data"):
                # already unpacked
                return
            if not self.data:
                # empty char
                del self.data
                self.numberOfContours = 0
                return
            dummy, data = sstruct.unpack2(glyphHeaderFormat, self.data, self)
            del self.data
            # Some fonts (eg. Neirizi.ttf) have a 0 for numberOfContours in
            # some glyphs; decompileCoordinates assumes that there's at least
            # one, so short-circuit here.
            if self.numberOfContours == 0:
                return
            if self.isComposite():
                self.decompileComponents(data, glyfTable)
            else:
                self.decompileCoordinates(data)

        def compile(
            self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=True
        ):
            if hasattr(self, "data"):
                if recalcBBoxes:
                    # must unpack glyph in order to recalculate bounding box
                    self.expand(glyfTable)
                else:
                    return self.data
            if self.numberOfContours == 0:
                return b""

            if recalcBBoxes:
                self.recalcBounds(glyfTable, boundsDone=boundsDone)

            data = sstruct.pack(glyphHeaderFormat, self)
            if self.isComposite():
                data = data + self.compileComponents(glyfTable)
            else:
                data = data + self.compileCoordinates(optimizeSize=optimizeSize)
            return data

        def toXML(self, writer, ttFont):
            if self.isComposite():
                for compo in self.components:
                    compo.toXML(writer, ttFont)
                haveInstructions = hasattr(self, "program")
            else:
                last = 0
                for i in range(self.numberOfContours):
                    writer.begintag("contour")
                    writer.newline()
                    for j in range(last, self.endPtsOfContours[i] + 1):
                        attrs = [
                            ("x", self.coordinates[j][0]),
                            ("y", self.coordinates[j][1]),
                            ("on", self.flags[j] & flagOnCurve),
                        ]
                        if self.flags[j] & flagOverlapSimple:
                            # Apple's rasterizer uses flagOverlapSimple in the first contour/first pt to flag glyphs that contain overlapping contours
                            attrs.append(("overlap", 1))
                        if self.flags[j] & flagCubic:
                            attrs.append(("cubic", 1))
                        writer.simpletag("pt", attrs)
                        writer.newline()
                    last = self.endPtsOfContours[i] + 1
                    writer.endtag("contour")
                    writer.newline()
                haveInstructions = self.numberOfContours > 0
            if haveInstructions:
                if self.program:
                    writer.begintag("instructions")
                    writer.newline()
                    self.program.toXML(writer, ttFont)
                    writer.endtag("instructions")
                else:
                    writer.simpletag("instructions")
                writer.newline()

        def fromXML(self, name, attrs, content, ttFont):
            if name == "contour":
                if self.numberOfContours < 0:
                    raise ttLib.TTLibError("can't mix composites and contours in glyph")
                self.numberOfContours = self.numberOfContours + 1
                coordinates = GlyphCoordinates()
                flags = bytearray()
                for element in content:
                    if not isinstance(element, tuple):
                        continue
                    name, attrs, content = element
                    if name != "pt":
                        continue  # ignore anything but "pt"
                    coordinates.append((safeEval(attrs["x"]), safeEval(attrs["y"])))
                    flag = bool(safeEval(attrs["on"]))
                    if "overlap" in attrs and bool(safeEval(attrs["overlap"])):
                        flag |= flagOverlapSimple
                    if "cubic" in attrs and bool(safeEval(attrs["cubic"])):
                        flag |= flagCubic
                    flags.append(flag)
                if not hasattr(self, "coordinates"):
                    self.coordinates = coordinates
                    self.flags = flags
                    self.endPtsOfContours = [len(coordinates) - 1]
                else:
                    self.coordinates.extend(coordinates)
                    self.flags.extend(flags)
                    self.endPtsOfContours.append(len(self.coordinates) - 1)
            elif name == "component":
                if self.numberOfContours > 0:
                    raise ttLib.TTLibError("can't mix composites and contours in glyph")
                self.numberOfContours = -1
                if not hasattr(self, "components"):
                    self.components = []
                component = GlyphComponent()
                self.components.append(component)
                component.fromXML(name, attrs, content, ttFont)
            elif name == "instructions":
                self.program = ttProgram.Program()
                for element in content:
                    if not isinstance(element, tuple):
                        continue
                    name, attrs, content = element
                    self.program.fromXML(name, attrs, content, ttFont)

        def getCompositeMaxpValues(self, glyfTable, maxComponentDepth=1):
            assert self.isComposite()
            nContours = 0
            nPoints = 0
            initialMaxComponentDepth = maxComponentDepth
            for compo in self.components:
                baseGlyph = glyfTable[compo.glyphName]
                if baseGlyph.numberOfContours == 0:
                    continue
                elif baseGlyph.numberOfContours > 0:
                    nP, nC = baseGlyph.getMaxpValues()
                else:
                    nP, nC, componentDepth = baseGlyph.getCompositeMaxpValues(
                        glyfTable, initialMaxComponentDepth + 1
                    )
                    maxComponentDepth = max(maxComponentDepth, componentDepth)
                nPoints = nPoints + nP
                nContours = nContours + nC
            return CompositeMaxpValues(nPoints, nContours, maxComponentDepth)

        def getMaxpValues(self):
            assert self.numberOfContours > 0
            return len(self.coordinates), len(self.endPtsOfContours)

        def decompileComponents(self, data, glyfTable):
            self.components = []
            more = 1
            haveInstructions = 0
            while more:
                component = GlyphComponent()
                more, haveInstr, data = component.decompile(data, glyfTable)
                haveInstructions = haveInstructions | haveInstr
                self.components.append(component)
            if haveInstructions:
                (numInstructions,) = struct.unpack(">h", data[:2])
                data = data[2:]
                self.program = ttProgram.Program()
                self.program.fromBytecode(data[:numInstructions])
                data = data[numInstructions:]
                if len(data) >= 4:
                    log.warning(
                        "too much glyph data at the end of composite glyph: %d excess bytes",
                        len(data),
                    )

        def decompileCoordinates(self, data):
            endPtsOfContours = array.array("H")
            endPtsOfContours.frombytes(data[: 2 * self.numberOfContours])
            if sys.byteorder != "big":
                endPtsOfContours.byteswap()
            self.endPtsOfContours = endPtsOfContours.tolist()

            pos = 2 * self.numberOfContours
            (instructionLength,) = struct.unpack(">h", data[pos : pos + 2])
            self.program = ttProgram.Program()
            self.program.fromBytecode(data[pos + 2 : pos + 2 + instructionLength])
            pos += 2 + instructionLength
            nCoordinates = self.endPtsOfContours[-1] + 1
            flags, xCoordinates, yCoordinates = self.decompileCoordinatesRaw(
                nCoordinates, data, pos
            )

            # fill in repetitions and apply signs
            self.coordinates = coordinates = GlyphCoordinates.zeros(nCoordinates)
            xIndex = 0
            yIndex = 0
            for i in range(nCoordinates):
                flag = flags[i]
                # x coordinate
                if flag & flagXShort:
                    if flag & flagXsame:
                        x = xCoordinates[xIndex]
                    else:
                        x = -xCoordinates[xIndex]
                    xIndex = xIndex + 1
                elif flag & flagXsame:
                    x = 0
                else:
                    x = xCoordinates[xIndex]
                    xIndex = xIndex + 1
                # y coordinate
                if flag & flagYShort:
                    if flag & flagYsame:
                        y = yCoordinates[yIndex]
                    else:
                        y = -yCoordinates[yIndex]
                    yIndex = yIndex + 1
                elif flag & flagYsame:
                    y = 0
                else:
                    y = yCoordinates[yIndex]
                    yIndex = yIndex + 1
                coordinates[i] = (x, y)
            assert xIndex == len(xCoordinates)
            assert yIndex == len(yCoordinates)
            coordinates.relativeToAbsolute()
            # discard all flags except "keepFlags"
            for i in range(len(flags)):
                flags[i] &= keepFlags
            self.flags = flags

        def decompileCoordinatesRaw(self, nCoordinates, data, pos=0):
            # unpack flags and prepare unpacking of coordinates
            flags = bytearray(nCoordinates)
            # Warning: deep Python trickery going on. We use the struct module to unpack
            # the coordinates. We build a format string based on the flags, so we can
            # unpack the coordinates in one struct.unpack() call.
            xFormat = ">"  # big endian
            yFormat = ">"  # big endian
            j = 0
            while True:
                flag = data[pos]
                pos += 1
                repeat = 1
                if flag & flagRepeat:
                    repeat = data[pos] + 1
                    pos += 1
                for k in range(repeat):
                    if flag & flagXShort:
                        xFormat = xFormat + "B"
                    elif not (flag & flagXsame):
                        xFormat = xFormat + "h"
                    if flag & flagYShort:
                        yFormat = yFormat + "B"
                    elif not (flag & flagYsame):
                        yFormat = yFormat + "h"
                    flags[j] = flag
                    j = j + 1
                if j >= nCoordinates:
                    break
            assert j == nCoordinates, "bad glyph flags"
            # unpack raw coordinates, krrrrrr-tching!
            xDataLen = struct.calcsize(xFormat)
            yDataLen = struct.calcsize(yFormat)
            if len(data) - pos - (xDataLen + yDataLen) >= 4:
                log.warning(
                    "too much glyph data: %d excess bytes",
                    len(data) - pos - (xDataLen + yDataLen),
                )
            xCoordinates = struct.unpack(xFormat, data[pos : pos + xDataLen])
            yCoordinates = struct.unpack(
                yFormat, data[pos + xDataLen : pos + xDataLen + yDataLen]
            )
            return flags, xCoordinates, yCoordinates

        def compileComponents(self, glyfTable):
            data = b""
            lastcomponent = len(self.components) - 1
            more = 1
            haveInstructions = 0
            for i, compo in enumerate(self.components):
                if i == lastcomponent:
                    haveInstructions = hasattr(self, "program")
                    more = 0
                data = data + compo.compile(more, haveInstructions, glyfTable)
            if haveInstructions:
                instructions = self.program.getBytecode()
                data = data + struct.pack(">h", len(instructions)) + instructions
            return data

        def compileCoordinates(self, *, optimizeSize=True):
            assert len(self.coordinates) == len(self.flags)
            data = []
            endPtsOfContours = array.array("H", self.endPtsOfContours)
            if sys.byteorder != "big":
                endPtsOfContours.byteswap()
            data.append(endPtsOfContours.tobytes())
            instructions = self.program.getBytecode()
            data.append(struct.pack(">h", len(instructions)))
            data.append(instructions)

            deltas = self.coordinates.copy()
            deltas.toInt()
            deltas.absoluteToRelative()

            if optimizeSize:
                # TODO(behdad): Add a configuration option for this?
                deltas = self.compileDeltasGreedy(self.flags, deltas)
                # deltas = self.compileDeltasOptimal(self.flags, deltas)
            else:
                deltas = self.compileDeltasForSpeed(self.flags, deltas)

            data.extend(deltas)
            return b"".join(data)

        def compileDeltasGreedy(self, flags, deltas):
            # Implements greedy algorithm for packing coordinate deltas:
            # uses shortest representation one coordinate at a time.
            compressedFlags = bytearray()
            compressedXs = bytearray()
            compressedYs = bytearray()
            lastflag = None
            repeat = 0
            for flag, (x, y) in zip(flags, deltas):
                # Oh, the horrors of TrueType
                # do x
                if x == 0:
                    flag = flag | flagXsame
                elif -255 <= x <= 255:
                    flag = flag | flagXShort
                    if x > 0:
                        flag = flag | flagXsame
                    else:
                        x = -x
                    compressedXs.append(x)
                else:
                    compressedXs.extend(struct.pack(">h", x))
                # do y
                if y == 0:
                    flag = flag | flagYsame
                elif -255 <= y <= 255:
                    flag = flag | flagYShort
                    if y > 0:
                        flag = flag | flagYsame
                    else:
                        y = -y
                    compressedYs.append(y)
                else:
                    compressedYs.extend(struct.pack(">h", y))
                # handle repeating flags
                if flag == lastflag and repeat != 255:
                    repeat = repeat + 1
                    if repeat == 1:
                        compressedFlags.append(flag)
                    else:
                        compressedFlags[-2] = flag | flagRepeat
                        compressedFlags[-1] = repeat
                else:
                    repeat = 0
                    compressedFlags.append(flag)
                lastflag = flag
            return (compressedFlags, compressedXs, compressedYs)

        def compileDeltasOptimal(self, flags, deltas):
            # Implements optimal, dynaic-programming, algorithm for packing coordinate
            # deltas.  The savings are negligible :(.
            candidates = []
            bestTuple = None
            bestCost = 0
            repeat = 0
            for flag, (x, y) in zip(flags, deltas):
                # Oh, the horrors of TrueType
                flag, coordBytes = flagBest(x, y, flag)
                bestCost += 1 + coordBytes
                newCandidates = [
                    (bestCost, bestTuple, flag, coordBytes),
                    (bestCost + 1, bestTuple, (flag | flagRepeat), coordBytes),
                ]
                for lastCost, lastTuple, lastFlag, coordBytes in candidates:
                    if (
                        lastCost + coordBytes <= bestCost + 1
                        and (lastFlag & flagRepeat)
                        and (lastFlag < 0xFF00)
                        and flagSupports(lastFlag, flag)
                    ):
                        if (lastFlag & 0xFF) == (
                            flag | flagRepeat
                        ) and lastCost == bestCost + 1:
                            continue
                        newCandidates.append(
                            (lastCost + coordBytes, lastTuple, lastFlag + 256, coordBytes)
                        )
                candidates = newCandidates
                bestTuple = min(candidates, key=lambda t: t[0])
                bestCost = bestTuple[0]

            flags = []
            while bestTuple:
                cost, bestTuple, flag, coordBytes = bestTuple
                flags.append(flag)
            flags.reverse()

            compressedFlags = bytearray()
            compressedXs = bytearray()
            compressedYs = bytearray()
            coords = iter(deltas)
            ff = []
            for flag in flags:
                repeatCount, flag = flag >> 8, flag & 0xFF
                compressedFlags.append(flag)
                if flag & flagRepeat:
                    assert repeatCount > 0
                    compressedFlags.append(repeatCount)
                else:
                    assert repeatCount == 0
                for i in range(1 + repeatCount):
                    x, y = next(coords)
                    flagEncodeCoords(flag, x, y, compressedXs, compressedYs)
                    ff.append(flag)
            try:
                next(coords)
                raise Exception("internal error")
            except StopIteration:
                pass

            return (compressedFlags, compressedXs, compressedYs)

        def compileDeltasForSpeed(self, flags, deltas):
            # uses widest representation needed, for all deltas.
            compressedFlags = bytearray()
            compressedXs = bytearray()
            compressedYs = bytearray()

            # Compute the necessary width for each axis
            xs = [d[0] for d in deltas]
            ys = [d[1] for d in deltas]
            minX, minY, maxX, maxY = min(xs), min(ys), max(xs), max(ys)
            xZero = minX == 0 and maxX == 0
            yZero = minY == 0 and maxY == 0
            xShort = -255 <= minX <= maxX <= 255
            yShort = -255 <= minY <= maxY <= 255

            lastflag = None
            repeat = 0
            for flag, (x, y) in zip(flags, deltas):
                # Oh, the horrors of TrueType
                # do x
                if xZero:
                    flag = flag | flagXsame
                elif xShort:
                    flag = flag | flagXShort
                    if x > 0:
                        flag = flag | flagXsame
                    else:
                        x = -x
                    compressedXs.append(x)
                else:
                    compressedXs.extend(struct.pack(">h", x))
                # do y
                if yZero:
                    flag = flag | flagYsame
                elif yShort:
                    flag = flag | flagYShort
                    if y > 0:
                        flag = flag | flagYsame
                    else:
                        y = -y
                    compressedYs.append(y)
                else:
                    compressedYs.extend(struct.pack(">h", y))
                # handle repeating flags
                if flag == lastflag and repeat != 255:
                    repeat = repeat + 1
                    if repeat == 1:
                        compressedFlags.append(flag)
                    else:
                        compressedFlags[-2] = flag | flagRepeat
                        compressedFlags[-1] = repeat
                else:
                    repeat = 0
                    compressedFlags.append(flag)
                lastflag = flag
            return (compressedFlags, compressedXs, compressedYs)

        def recalcBounds(self, glyfTable, *, boundsDone=None):
            """Recalculates the bounds of the glyph.

            Each glyph object stores its bounding box in the
            ``xMin``/``yMin``/``xMax``/``yMax`` attributes. These bounds must be
            recomputed when the ``coordinates`` change. The ``table__g_l_y_f`` bounds
            must be provided to resolve component bounds.
            """
            if self.isComposite() and self.tryRecalcBoundsComposite(
                glyfTable, boundsDone=boundsDone
            ):
                return
            try:
                coords, endPts, flags = self.getCoordinates(glyfTable, round=otRound)
                self.xMin, self.yMin, self.xMax, self.yMax = coords.calcIntBounds()
            except NotImplementedError:
                pass

        def tryRecalcBoundsComposite(self, glyfTable, *, boundsDone=None):
            """Try recalculating the bounds of a composite glyph that has
            certain constrained properties. Namely, none of the components
            have a transform other than an integer translate, and none
            uses the anchor points.

            Each glyph object stores its bounding box in the
            ``xMin``/``yMin``/``xMax``/``yMax`` attributes. These bounds must be
            recomputed when the ``coordinates`` change. The ``table__g_l_y_f`` bounds
            must be provided to resolve component bounds.

            Return True if bounds were calculated, False otherwise.
            """
            for compo in self.components:
                if not compo._hasOnlyIntegerTranslate():
                    return False

            # All components are untransformed and have an integer x/y translate
            bounds = None
            for compo in self.components:
                glyphName = compo.glyphName
                g = glyfTable[glyphName]

                if boundsDone is None or glyphName not in boundsDone:
                    g.recalcBounds(glyfTable, boundsDone=boundsDone)
                    if boundsDone is not None:
                        boundsDone.add(glyphName)
                # empty components shouldn't update the bounds of the parent glyph
                if g.yMin == g.yMax and g.xMin == g.xMax:
                    continue

                x, y = compo.x, compo.y
                bounds = updateBounds(bounds, (g.xMin + x, g.yMin + y))
                bounds = updateBounds(bounds, (g.xMax + x, g.yMax + y))

            if bounds is None:
                bounds = (0, 0, 0, 0)
            self.xMin, self.yMin, self.xMax, self.yMax = bounds
            return True

        def isComposite(self):
            """Test whether a glyph has components"""
            if hasattr(self, "data"):
                return struct.unpack(">h", self.data[:2])[0] == -1 if self.data else False
            else:
                return self.numberOfContours == -1

        def getCoordinates(self, glyfTable, *, round=noRound):
            """Return the coordinates, end points and flags

            This method returns three values: A :py:class:`GlyphCoordinates` object,
            a list of the indexes of the final points of each contour (allowing you
            to split up the coordinates list into contours) and a list of flags.

            On simple glyphs, this method returns information from the glyph's own
            contours; on composite glyphs, it "flattens" all components recursively
            to return a list of coordinates representing all the components involved
            in the glyph.

            To interpret the flags for each point, see the "Simple Glyph Flags"
            section of the `glyf table specification <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#simple-glyph-description>`.
            """

            if self.numberOfContours > 0:
                return self.coordinates, self.endPtsOfContours, self.flags
            elif self.isComposite():
                # it's a composite
                allCoords = GlyphCoordinates()
                allFlags = bytearray()
                allEndPts = []
                for compo in self.components:
                    g = glyfTable[compo.glyphName]
                    try:
                        coordinates, endPts, flags = g.getCoordinates(
                            glyfTable, round=round
                        )
                    except RecursionError:
                        raise ttLib.TTLibError(
                            "glyph '%s' contains a recursive component reference"
                            % compo.glyphName
                        )
                    coordinates = GlyphCoordinates(coordinates)
                    # if asked to round e.g. while computing bboxes, it's important we
                    # do it immediately before a component transform is applied to a
                    # simple glyph's coordinates in case these might still contain floats;
                    # however, if the referenced component glyph is another composite, we
                    # must not round here but only at the end, after all the nested
                    # transforms have been applied, or else rounding errors will compound.
                    if round is not noRound and g.numberOfContours > 0:
                        coordinates.toInt(round=round)
                    if hasattr(compo, "firstPt"):
                        # component uses two reference points: we apply the transform _before_
                        # computing the offset between the points
                        if hasattr(compo, "transform"):
                            coordinates.transform(compo.transform)
                        x1, y1 = allCoords[compo.firstPt]
                        x2, y2 = coordinates[compo.secondPt]
                        move = x1 - x2, y1 - y2
                        coordinates.translate(move)
                    else:
                        # component uses XY offsets
                        move = compo.x, compo.y
                        if not hasattr(compo, "transform"):
                            coordinates.translate(move)
                        else:
                            apple_way = compo.flags & SCALED_COMPONENT_OFFSET
                            ms_way = compo.flags & UNSCALED_COMPONENT_OFFSET
                            assert not (apple_way and ms_way)
                            if not (apple_way or ms_way):
                                scale_component_offset = (
                                    SCALE_COMPONENT_OFFSET_DEFAULT  # see top of this file
                                )
                            else:
                                scale_component_offset = apple_way
                            if scale_component_offset:
                                # the Apple way: first move, then scale (ie. scale the component offset)
                                coordinates.translate(move)
                                coordinates.transform(compo.transform)
                            else:
                                # the MS way: first scale, then move
                                coordinates.transform(compo.transform)
                                coordinates.translate(move)
                    offset = len(allCoords)
                    allEndPts.extend(e + offset for e in endPts)
                    allCoords.extend(coordinates)
                    allFlags.extend(flags)
                return allCoords, allEndPts, allFlags
            else:
                return GlyphCoordinates(), [], bytearray()

        def getComponentNames(self, glyfTable):
            """Returns a list of names of component glyphs used in this glyph

            This method can be used on simple glyphs (in which case it returns an
            empty list) or composite glyphs.
            """
            if not hasattr(self, "data"):
                if self.isComposite():
                    return [c.glyphName for c in self.components]
                else:
                    return []

            # Extract components without expanding glyph

            if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0:
                return []  # Not composite

            data = self.data
            i = 10
            components = []
            more = 1
            while more:
                flags, glyphID = struct.unpack(">HH", data[i : i + 4])
                i += 4
                flags = int(flags)
                components.append(glyfTable.getGlyphName(int(glyphID)))

                if flags & ARG_1_AND_2_ARE_WORDS:
                    i += 4
                else:
                    i += 2
                if flags & WE_HAVE_A_SCALE:
                    i += 2
                elif flags & WE_HAVE_AN_X_AND_Y_SCALE:
                    i += 4
                elif flags & WE_HAVE_A_TWO_BY_TWO:
                    i += 8
                more = flags & MORE_COMPONENTS

            return components

        def trim(self, remove_hinting=False):
            """Remove padding and, if requested, hinting, from a glyph.
            This works on both expanded and compacted glyphs, without
            expanding it."""
            if not hasattr(self, "data"):
                if remove_hinting:
                    if self.isComposite():
                        if hasattr(self, "program"):
                            del self.program
                    else:
                        self.program = ttProgram.Program()
                        self.program.fromBytecode([])
                # No padding to trim.
                return
            if not self.data:
                return
            numContours = struct.unpack(">h", self.data[:2])[0]
            data = bytearray(self.data)
            i = 10
            if numContours >= 0:
                i += 2 * numContours  # endPtsOfContours
                nCoordinates = ((data[i - 2] << 8) | data[i - 1]) + 1
                instructionLen = (data[i] << 8) | data[i + 1]
                if remove_hinting:
                    # Zero instruction length
                    data[i] = data[i + 1] = 0
                    i += 2
                    if instructionLen:
                        # Splice it out
                        data = data[:i] + data[i + instructionLen :]
                    instructionLen = 0
                else:
                    i += 2 + instructionLen

                coordBytes = 0
                j = 0
                while True:
                    flag = data[i]
                    i = i + 1
                    repeat = 1
                    if flag & flagRepeat:
                        repeat = data[i] + 1
                        i = i + 1
                    xBytes = yBytes = 0
                    if flag & flagXShort:
                        xBytes = 1
                    elif not (flag & flagXsame):
                        xBytes = 2
                    if flag & flagYShort:
                        yBytes = 1
                    elif not (flag & flagYsame):
                        yBytes = 2
                    coordBytes += (xBytes + yBytes) * repeat
                    j += repeat
                    if j >= nCoordinates:
                        break
                assert j == nCoordinates, "bad glyph flags"
                i += coordBytes
                # Remove padding
                data = data[:i]
            elif self.isComposite():
                more = 1
                we_have_instructions = False
                while more:
                    flags = (data[i] << 8) | data[i + 1]
                    if remove_hinting:
                        flags &= ~WE_HAVE_INSTRUCTIONS
                    if flags & WE_HAVE_INSTRUCTIONS:
                        we_have_instructions = True
                    data[i + 0] = flags >> 8
                    data[i + 1] = flags & 0xFF
                    i += 4
                    flags = int(flags)

                    if flags & ARG_1_AND_2_ARE_WORDS:
                        i += 4
                    else:
                        i += 2
                    if flags & WE_HAVE_A_SCALE:
                        i += 2
                    elif flags & WE_HAVE_AN_X_AND_Y_SCALE:
                        i += 4
                    elif flags & WE_HAVE_A_TWO_BY_TWO:
                        i += 8
                    more = flags & MORE_COMPONENTS
                if we_have_instructions:
                    instructionLen = (data[i] << 8) | data[i + 1]
                    i += 2 + instructionLen
                # Remove padding
                data = data[:i]

            self.data = data

        def removeHinting(self):
            """Removes TrueType hinting instructions from the glyph."""
            self.trim(remove_hinting=True)

        def draw(self, pen, glyfTable, offset=0):
            """Draws the glyph using the supplied pen object.

            Arguments:
                    pen: An object conforming to the pen protocol.
                    glyfTable: A :py:class:`table__g_l_y_f` object, to resolve components.
                    offset (int): A horizontal offset. If provided, all coordinates are
                            translated by this offset.
            """

            if self.isComposite():
                for component in self.components:
                    glyphName, transform = component.getComponentInfo()
                    pen.addComponent(glyphName, transform)
                return

            self.expand(glyfTable)
            coordinates, endPts, flags = self.getCoordinates(glyfTable)
            if offset:
                coordinates = coordinates.copy()
                coordinates.translate((offset, 0))
            start = 0
            maybeInt = lambda v: int(v) if v == int(v) else v
            for end in endPts:
                end = end + 1
                contour = coordinates[start:end]
                cFlags = [flagOnCurve & f for f in flags[start:end]]
                cuFlags = [flagCubic & f for f in flags[start:end]]
                start = end
                if 1 not in cFlags:
                    assert all(cuFlags) or not any(cuFlags)
                    cubic = all(cuFlags)
                    if cubic:
                        count = len(contour)
                        assert count % 2 == 0, "Odd number of cubic off-curves undefined"
                        l = contour[-1]
                        f = contour[0]
                        p0 = (maybeInt((l[0] + f[0]) * 0.5), maybeInt((l[1] + f[1]) * 0.5))
                        pen.moveTo(p0)
                        for i in range(0, count, 2):
                            p1 = contour[i]
                            p2 = contour[i + 1]
                            p4 = contour[i + 2 if i + 2 < count else 0]
                            p3 = (
                                maybeInt((p2[0] + p4[0]) * 0.5),
                                maybeInt((p2[1] + p4[1]) * 0.5),
                            )
                            pen.curveTo(p1, p2, p3)
                    else:
                        # There is not a single on-curve point on the curve,
                        # use pen.qCurveTo's special case by specifying None
                        # as the on-curve point.
                        contour.append(None)
                        pen.qCurveTo(*contour)
                else:
                    # Shuffle the points so that the contour is guaranteed
                    # to *end* in an on-curve point, which we'll use for
                    # the moveTo.
                    firstOnCurve = cFlags.index(1) + 1
                    contour = contour[firstOnCurve:] + contour[:firstOnCurve]
                    cFlags = cFlags[firstOnCurve:] + cFlags[:firstOnCurve]
                    cuFlags = cuFlags[firstOnCurve:] + cuFlags[:firstOnCurve]
                    pen.moveTo(contour[-1])
                    while contour:
                        nextOnCurve = cFlags.index(1) + 1
                        if nextOnCurve == 1:
                            # Skip a final lineTo(), as it is implied by
                            # pen.closePath()
                            if len(contour) > 1:
                                pen.lineTo(contour[0])
                        else:
                            cubicFlags = [f for f in cuFlags[: nextOnCurve - 1]]
                            assert all(cubicFlags) or not any(cubicFlags)
                            cubic = any(cubicFlags)
                            if cubic:
                                assert all(
                                    cubicFlags
                                ), "Mixed cubic and quadratic segment undefined"

                                count = nextOnCurve
                                assert (
                                    count >= 3
                                ), "At least two cubic off-curve points required"
                                assert (
                                    count - 1
                                ) % 2 == 0, "Odd number of cubic off-curves undefined"
                                for i in range(0, count - 3, 2):
                                    p1 = contour[i]
                                    p2 = contour[i + 1]
                                    p4 = contour[i + 2]
                                    p3 = (
                                        maybeInt((p2[0] + p4[0]) * 0.5),
                                        maybeInt((p2[1] + p4[1]) * 0.5),
                                    )
                                    lastOnCurve = p3
                                    pen.curveTo(p1, p2, p3)
                                pen.curveTo(*contour[count - 3 : count])
                            else:
                                pen.qCurveTo(*contour[:nextOnCurve])
                        contour = contour[nextOnCurve:]
                        cFlags = cFlags[nextOnCurve:]
                        cuFlags = cuFlags[nextOnCurve:]
                pen.closePath()

        def drawPoints(self, pen, glyfTable, offset=0):
            """Draw the glyph using the supplied pointPen. As opposed to Glyph.draw(),
            this will not change the point indices.
            """

            if self.isComposite():
                for component in self.components:
                    glyphName, transform = component.getComponentInfo()
                    pen.addComponent(glyphName, transform)
                return

            coordinates, endPts, flags = self.getCoordinates(glyfTable)
            if offset:
                coordinates = coordinates.copy()
                coordinates.translate((offset, 0))
            start = 0
            for end in endPts:
                end = end + 1
                contour = coordinates[start:end]
                cFlags = flags[start:end]
                start = end
                pen.beginPath()
                # Start with the appropriate segment type based on the final segment

                if cFlags[-1] & flagOnCurve:
                    segmentType = "line"
                elif cFlags[-1] & flagCubic:
                    segmentType = "curve"
                else:
                    segmentType = "qcurve"
                for i, pt in enumerate(contour):
                    if cFlags[i] & flagOnCurve:
                        pen.addPoint(pt, segmentType=segmentType)
                        segmentType = "line"
                    else:
                        pen.addPoint(pt)
                        segmentType = "curve" if cFlags[i] & flagCubic else "qcurve"
                pen.endPath()

        def __eq__(self, other):
            if type(self) != type(other):
                return NotImplemented
            return self.__dict__ == other.__dict__

        def __ne__(self, other):
            result = self.__eq__(other)
            return result if result is NotImplemented else not result

    # Vector.__round__ uses the built-in (Banker's) `round` but we want
    # to use otRound below
    _roundv = partial(Vector.__round__, round=otRound)

    def _is_mid_point(p0: tuple, p1: tuple, p2: tuple) -> bool:
        # True if p1 is in the middle of p0 and p2, either before or after rounding
        p0 = Vector(p0)
        p1 = Vector(p1)
        p2 = Vector(p2)
        return ((p0 + p2) * 0.5).isclose(p1) or _roundv(p0) + _roundv(p2) == _roundv(p1) * 2

    def dropImpliedOnCurvePoints(*interpolatable_glyphs: Glyph) -> Set[int]:
        """Drop impliable on-curve points from the (simple) glyph or glyphs.

        In TrueType glyf outlines, on-curve points can be implied when they are located at
        the midpoint of the line connecting two consecutive off-curve points.

        If more than one glyphs are passed, these are assumed to be interpolatable masters
        of the same glyph impliable, and thus only the on-curve points that are impliable
        for all of them will actually be implied.
        Composite glyphs or empty glyphs are skipped, only simple glyphs with 1 or more
        contours are considered.
        The input glyph(s) is/are modified in-place.

        Args:
            interpolatable_glyphs: The glyph or glyphs to modify in-place.

        Returns:
            The set of point indices that were dropped if any.

        Raises:
            ValueError if simple glyphs are not in fact interpolatable because they have
            different point flags or number of contours.

        Reference:
        https://developer.apple.com/fonts/TrueType-Reference-Manual/RM01/Chap1.html
        """
        staticAttributes = SimpleNamespace(
            numberOfContours=None, flags=None, endPtsOfContours=None
        )
        drop = None
        simple_glyphs = []
        for i, glyph in enumerate(interpolatable_glyphs):
            if glyph.numberOfContours < 1:
                # ignore composite or empty glyphs
                continue

            for attr in staticAttributes.__dict__:
                expected = getattr(staticAttributes, attr)
                found = getattr(glyph, attr)
                if expected is None:
                    setattr(staticAttributes, attr, found)
                elif expected != found:
                    raise ValueError(
                        f"Incompatible {attr} for glyph at master index {i}: "
                        f"expected {expected}, found {found}"
                    )

            may_drop = set()
            start = 0
            coords = glyph.coordinates
            flags = staticAttributes.flags
            endPtsOfContours = staticAttributes.endPtsOfContours
            for last in endPtsOfContours:
                for i in range(start, last + 1):
                    if not (flags[i] & flagOnCurve):
                        continue
                    prv = i - 1 if i > start else last
                    nxt = i + 1 if i < last else start
                    if (flags[prv] & flagOnCurve) or flags[prv] != flags[nxt]:
                        continue
                    # we may drop the ith on-curve if halfway between previous/next off-curves
                    if not _is_mid_point(coords[prv], coords[i], coords[nxt]):
                        continue

                    may_drop.add(i)
                start = last + 1
            # we only want to drop if ALL interpolatable glyphs have the same implied oncurves
            if drop is None:
                drop = may_drop
            else:
                drop.intersection_update(may_drop)

            simple_glyphs.append(glyph)

        if drop:
            # Do the actual dropping
            flags = staticAttributes.flags
            assert flags is not None
            newFlags = array.array(
                "B", (flags[i] for i in range(len(flags)) if i not in drop)
            )

            endPts = staticAttributes.endPtsOfContours
            assert endPts is not None
            newEndPts = []
            i = 0
            delta = 0
            for d in sorted(drop):
                while d > endPts[i]:
                    newEndPts.append(endPts[i] - delta)
                    i += 1
                delta += 1
            while i < len(endPts):
                newEndPts.append(endPts[i] - delta)
                i += 1

            for glyph in simple_glyphs:
                coords = glyph.coordinates
                glyph.coordinates = GlyphCoordinates(
                    coords[i] for i in range(len(coords)) if i not in drop
                )
                glyph.flags = newFlags
                glyph.endPtsOfContours = newEndPts

        return drop if drop is not None else set()

    class GlyphComponent(object):
        """Represents a component within a composite glyph.

        The component is represented internally with four attributes: ``glyphName``,
        ``x``, ``y`` and ``transform``. If there is no "two-by-two" matrix (i.e
        no scaling, reflection, or rotation; only translation), the ``transform``
        attribute is not present.
        """

        # The above documentation is not *completely* true, but is *true enough* because
        # the rare firstPt/lastPt attributes are not totally supported and nobody seems to
        # mind - see below.

        def __init__(self):
            pass

        def getComponentInfo(self):
            """Return information about the component

            This method returns a tuple of two values: the glyph name of the component's
            base glyph, and a transformation matrix. As opposed to accessing the attributes
            directly, ``getComponentInfo`` always returns a six-element tuple of the
            component's transformation matrix, even when the two-by-two ``.transform``
            matrix is not present.
            """
            # XXX Ignoring self.firstPt & self.lastpt for now: I need to implement
            # something equivalent in fontTools.objects.glyph (I'd rather not
            # convert it to an absolute offset, since it is valuable information).
            # This method will now raise "AttributeError: x" on glyphs that use
            # this TT feature.
            if hasattr(self, "transform"):
                [[xx, xy], [yx, yy]] = self.transform
                trans = (xx, xy, yx, yy, self.x, self.y)
            else:
                trans = (1, 0, 0, 1, self.x, self.y)
            return self.glyphName, trans

        def decompile(self, data, glyfTable):
            flags, glyphID = struct.unpack(">HH", data[:4])
            self.flags = int(flags)
            glyphID = int(glyphID)
            self.glyphName = glyfTable.getGlyphName(int(glyphID))
            data = data[4:]

            if self.flags & ARG_1_AND_2_ARE_WORDS:
                if self.flags & ARGS_ARE_XY_VALUES:
                    self.x, self.y = struct.unpack(">hh", data[:4])
                else:
                    x, y = struct.unpack(">HH", data[:4])
                    self.firstPt, self.secondPt = int(x), int(y)
                data = data[4:]
            else:
                if self.flags & ARGS_ARE_XY_VALUES:
                    self.x, self.y = struct.unpack(">bb", data[:2])
                else:
                    x, y = struct.unpack(">BB", data[:2])
                    self.firstPt, self.secondPt = int(x), int(y)
                data = data[2:]

            if self.flags & WE_HAVE_A_SCALE:
                (scale,) = struct.unpack(">h", data[:2])
                self.transform = [
                    [fi2fl(scale, 14), 0],
                    [0, fi2fl(scale, 14)],
                ]  # fixed 2.14
                data = data[2:]
            elif self.flags & WE_HAVE_AN_X_AND_Y_SCALE:
                xscale, yscale = struct.unpack(">hh", data[:4])
                self.transform = [
                    [fi2fl(xscale, 14), 0],
                    [0, fi2fl(yscale, 14)],
                ]  # fixed 2.14
                data = data[4:]
            elif self.flags & WE_HAVE_A_TWO_BY_TWO:
                (xscale, scale01, scale10, yscale) = struct.unpack(">hhhh", data[:8])
                self.transform = [
                    [fi2fl(xscale, 14), fi2fl(scale01, 14)],
                    [fi2fl(scale10, 14), fi2fl(yscale, 14)],
                ]  # fixed 2.14
                data = data[8:]
            more = self.flags & MORE_COMPONENTS
            haveInstructions = self.flags & WE_HAVE_INSTRUCTIONS
            self.flags = self.flags & (
                ROUND_XY_TO_GRID
                | USE_MY_METRICS
                | SCALED_COMPONENT_OFFSET
                | UNSCALED_COMPONENT_OFFSET
                | NON_OVERLAPPING
                | OVERLAP_COMPOUND
            )
            return more, haveInstructions, data

        def compile(self, more, haveInstructions, glyfTable):
            data = b""

            # reset all flags we will calculate ourselves
            flags = self.flags & (
                ROUND_XY_TO_GRID
                | USE_MY_METRICS
                | SCALED_COMPONENT_OFFSET
                | UNSCALED_COMPONENT_OFFSET
                | NON_OVERLAPPING
                | OVERLAP_COMPOUND
            )
            if more:
                flags = flags | MORE_COMPONENTS
            if haveInstructions:
                flags = flags | WE_HAVE_INSTRUCTIONS

            if hasattr(self, "firstPt"):
                if (0 <= self.firstPt <= 255) and (0 <= self.secondPt <= 255):
                    data = data + struct.pack(">BB", self.firstPt, self.secondPt)
                else:
                    data = data + struct.pack(">HH", self.firstPt, self.secondPt)
                    flags = flags | ARG_1_AND_2_ARE_WORDS
            else:
                x = otRound(self.x)
                y = otRound(self.y)
                flags = flags | ARGS_ARE_XY_VALUES
                if (-128 <= x <= 127) and (-128 <= y <= 127):
                    data = data + struct.pack(">bb", x, y)
                else:
                    data = data + struct.pack(">hh", x, y)
                    flags = flags | ARG_1_AND_2_ARE_WORDS

            if hasattr(self, "transform"):
                transform = [[fl2fi(x, 14) for x in row] for row in self.transform]
                if transform[0][1] or transform[1][0]:
                    flags = flags | WE_HAVE_A_TWO_BY_TWO
                    data = data + struct.pack(
                        ">hhhh",
                        transform[0][0],
                        transform[0][1],
                        transform[1][0],
                        transform[1][1],
                    )
                elif transform[0][0] != transform[1][1]:
                    flags = flags | WE_HAVE_AN_X_AND_Y_SCALE
                    data = data + struct.pack(">hh", transform[0][0], transform[1][1])
                else:
                    flags = flags | WE_HAVE_A_SCALE
                    data = data + struct.pack(">h", transform[0][0])

            glyphID = glyfTable.getGlyphID(self.glyphName)
            return struct.pack(">HH", flags, glyphID) + data

        def toXML(self, writer, ttFont):
            attrs = [("glyphName", self.glyphName)]
            if not hasattr(self, "firstPt"):
                attrs = attrs + [("x", self.x), ("y", self.y)]
            else:
                attrs = attrs + [("firstPt", self.firstPt), ("secondPt", self.secondPt)]

            if hasattr(self, "transform"):
                transform = self.transform
                if transform[0][1] or transform[1][0]:
                    attrs = attrs + [
                        ("scalex", fl2str(transform[0][0], 14)),
                        ("scale01", fl2str(transform[0][1], 14)),
                        ("scale10", fl2str(transform[1][0], 14)),
                        ("scaley", fl2str(transform[1][1], 14)),
                    ]
                elif transform[0][0] != transform[1][1]:
                    attrs = attrs + [
                        ("scalex", fl2str(transform[0][0], 14)),
                        ("scaley", fl2str(transform[1][1], 14)),
                    ]
                else:
                    attrs = attrs + [("scale", fl2str(transform[0][0], 14))]
            attrs = attrs + [("flags", hex(self.flags))]
            writer.simpletag("component", attrs)
            writer.newline()

        def fromXML(self, name, attrs, content, ttFont):
            self.glyphName = attrs["glyphName"]
            if "firstPt" in attrs:
                self.firstPt = safeEval(attrs["firstPt"])
                self.secondPt = safeEval(attrs["secondPt"])
            else:
                self.x = safeEval(attrs["x"])
                self.y = safeEval(attrs["y"])
            if "scale01" in attrs:
                scalex = str2fl(attrs["scalex"], 14)
                scale01 = str2fl(attrs["scale01"], 14)
                scale10 = str2fl(attrs["scale10"], 14)
                scaley = str2fl(attrs["scaley"], 14)
                self.transform = [[scalex, scale01], [scale10, scaley]]
            elif "scalex" in attrs:
                scalex = str2fl(attrs["scalex"], 14)
                scaley = str2fl(attrs["scaley"], 14)
                self.transform = [[scalex, 0], [0, scaley]]
            elif "scale" in attrs:
                scale = str2fl(attrs["scale"], 14)
                self.transform = [[scale, 0], [0, scale]]
            self.flags = safeEval(attrs["flags"])

        def __eq__(self, other):
            if type(self) != type(other):
                return NotImplemented
            return self.__dict__ == other.__dict__

        def __ne__(self, other):
            result = self.__eq__(other)
            return result if result is NotImplemented else not result

        def _hasOnlyIntegerTranslate(self):
            """Return True if it's a 'simple' component.

            That is, it has no anchor points and no transform other than integer translate.
            """
            return (
                not hasattr(self, "firstPt")
                and not hasattr(self, "transform")
                and float(self.x).is_integer()
                and float(self.y).is_integer()
            )

    class GlyphCoordinates(object):
        """A list of glyph coordinates.

        Unlike an ordinary list, this is a numpy-like matrix object which supports
        matrix addition, scalar multiplication and other operations described below.
        """

        def __init__(self, iterable=[]):
            self._a = array.array("d")
            self.extend(iterable)

        @property
        def array(self):
            """Returns the underlying array of coordinates"""
            return self._a

        @staticmethod
        def zeros(count):
            """Creates a new ``GlyphCoordinates`` object with all coordinates set to (0,0)"""
            g = GlyphCoordinates()
            g._a.frombytes(bytes(count * 2 * g._a.itemsize))
            return g

        def copy(self):
            """Creates a new ``GlyphCoordinates`` object which is a copy of the current one."""
            c = GlyphCoordinates()
            c._a.extend(self._a)
            return c

        def __len__(self):
            """Returns the number of coordinates in the array."""
            return len(self._a) // 2

        def __getitem__(self, k):
            """Returns a two element tuple (x,y)"""
            a = self._a
            if isinstance(k, slice):
                indices = range(*k.indices(len(self)))
                # Instead of calling ourselves recursively, duplicate code; faster
                ret = []
                for k in indices:
                    x = a[2 * k]
                    y = a[2 * k + 1]
                    ret.append(
                        (int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)
                    )
                return ret
            x = a[2 * k]
            y = a[2 * k + 1]
            return (int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)

        def __setitem__(self, k, v):
            """Sets a point's coordinates to a two element tuple (x,y)"""
            if isinstance(k, slice):
                indices = range(*k.indices(len(self)))
                # XXX This only works if len(v) == len(indices)
                for j, i in enumerate(indices):
                    self[i] = v[j]
                return
            self._a[2 * k], self._a[2 * k + 1] = v

        def __delitem__(self, i):
            """Removes a point from the list"""
            i = (2 * i) % len(self._a)
            del self._a[i]
            del self._a[i]

        def __repr__(self):
            return "GlyphCoordinates([" + ",".join(str(c) for c in self) + "])"

        def append(self, p):
            self._a.extend(tuple(p))

        def extend(self, iterable):
            for p in iterable:
                self._a.extend(p)

        def toInt(self, *, round=otRound):
            if round is noRound:
                return
            a = self._a
            for i, value in enumerate(a):
                a[i] = round(value)

        def calcBounds(self):
            a = self._a
            if not a:
                return 0, 0, 0, 0
            xs = a[0::2]
            ys = a[1::2]
            return min(xs), min(ys), max(xs), max(ys)

        def calcIntBounds(self, round=otRound):
            return tuple(round(v) for v in self.calcBounds())

        def relativeToAbsolute(self):
            a = self._a
            x, y = 0, 0
            for i in range(0, len(a), 2):
                a[i] = x = a[i] + x
                a[i + 1] = y = a[i + 1] + y

        def absoluteToRelative(self):
            a = self._a
            x, y = 0, 0
            for i in range(0, len(a), 2):
                nx = a[i]
                ny = a[i + 1]
                a[i] = nx - x
                a[i + 1] = ny - y
                x = nx
                y = ny

        def translate(self, p):
            """
            >>> GlyphCoordinates([(1,2)]).translate((.5,0))
            """
            x, y = p
            if x == 0 and y == 0:
                return
            a = self._a
            for i in range(0, len(a), 2):
                a[i] += x
                a[i + 1] += y

        def scale(self, p):
            """
            >>> GlyphCoordinates([(1,2)]).scale((.5,0))
            """
            x, y = p
            if x == 1 and y == 1:
                return
            a = self._a
            for i in range(0, len(a), 2):
                a[i] *= x
                a[i + 1] *= y

        def transform(self, t):
            """
            >>> GlyphCoordinates([(1,2)]).transform(((.5,0),(.2,.5)))
            """
            a = self._a
            for i in range(0, len(a), 2):
                x = a[i]
                y = a[i + 1]
                px = x * t[0][0] + y * t[1][0]
                py = x * t[0][1] + y * t[1][1]
                a[i] = px
                a[i + 1] = py

        def __eq__(self, other):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g2 = GlyphCoordinates([(1.0,2)])
            >>> g3 = GlyphCoordinates([(1.5,2)])
            >>> g == g2
            True
            >>> g == g3
            False
            >>> g2 == g3
            False
            """
            if type(self) != type(other):
                return NotImplemented
            return self._a == other._a

        def __ne__(self, other):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g2 = GlyphCoordinates([(1.0,2)])
            >>> g3 = GlyphCoordinates([(1.5,2)])
            >>> g != g2
            False
            >>> g != g3
            True
            >>> g2 != g3
            True
            """
            result = self.__eq__(other)
            return result if result is NotImplemented else not result

        # Math operations

        def __pos__(self):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g
            GlyphCoordinates([(1, 2)])
            >>> g2 = +g
            >>> g2
            GlyphCoordinates([(1, 2)])
            >>> g2.translate((1,0))
            >>> g2
            GlyphCoordinates([(2, 2)])
            >>> g
            GlyphCoordinates([(1, 2)])
            """
            return self.copy()

        def __neg__(self):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g
            GlyphCoordinates([(1, 2)])
            >>> g2 = -g
            >>> g2
            GlyphCoordinates([(-1, -2)])
            >>> g
            GlyphCoordinates([(1, 2)])
            """
            r = self.copy()
            a = r._a
            for i, value in enumerate(a):
                a[i] = -value
            return r

        def __round__(self, *, round=otRound):
            r = self.copy()
            r.toInt(round=round)
            return r

        def __add__(self, other):
            return self.copy().__iadd__(other)

        def __sub__(self, other):
            return self.copy().__isub__(other)

        def __mul__(self, other):
            return self.copy().__imul__(other)

        def __truediv__(self, other):
            return self.copy().__itruediv__(other)

        __radd__ = __add__
        __rmul__ = __mul__

        def __rsub__(self, other):
            return other + (-self)

        def __iadd__(self, other):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g += (.5,0)
            >>> g
            GlyphCoordinates([(1.5, 2)])
            >>> g2 = GlyphCoordinates([(3,4)])
            >>> g += g2
            >>> g
            GlyphCoordinates([(4.5, 6)])
            """
            if isinstance(other, tuple):
                assert len(other) == 2
                self.translate(other)
                return self
            if isinstance(other, GlyphCoordinates):
                other = other._a
                a = self._a
                assert len(a) == len(other)
                for i, value in enumerate(other):
                    a[i] += value
                return self
            return NotImplemented

        def __isub__(self, other):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g -= (.5,0)
            >>> g
            GlyphCoordinates([(0.5, 2)])
            >>> g2 = GlyphCoordinates([(3,4)])
            >>> g -= g2
            >>> g
            GlyphCoordinates([(-2.5, -2)])
            """
            if isinstance(other, tuple):
                assert len(other) == 2
                self.translate((-other[0], -other[1]))
                return self
            if isinstance(other, GlyphCoordinates):
                other = other._a
                a = self._a
                assert len(a) == len(other)
                for i, value in enumerate(other):
                    a[i] -= value
                return self
            return NotImplemented

        def __imul__(self, other):
            """
            >>> g = GlyphCoordinates([(1,2)])
            >>> g *= (2,.5)
            >>> g *= 2
            >>> g
            GlyphCoordinates([(4, 2)])
            >>> g = GlyphCoordinates([(1,2)])
            >>> g *= 2
            >>> g
            GlyphCoordinates([(2, 4)])
            """
            if isinstance(other, tuple):
                assert len(other) == 2
                self.scale(other)
                return self
            if isinstance(other, Number):
                if other == 1:
                    return self
                a = self._a
                for i in range(len(a)):
                    a[i] *= other
                return self
            return NotImplemented

        def __itruediv__(self, other):
            """
            >>> g = GlyphCoordinates([(1,3)])
            >>> g /= (.5,1.5)
            >>> g /= 2
            >>> g
            GlyphCoordinates([(1, 1)])
            """
            if isinstance(other, Number):
                other = (other, other)
            if isinstance(other, tuple):
                if other == (1, 1):
                    return self
                assert len(other) == 2
                self.scale((1.0 / other[0], 1.0 / other[1]))
                return self
            return NotImplemented

        def __bool__(self):
            """
            >>> g = GlyphCoordinates([])
            >>> bool(g)
            False
            >>> g = GlyphCoordinates([(0,0), (0.,0)])
            >>> bool(g)
            True
            >>> g = GlyphCoordinates([(0,0), (1,0)])
            >>> bool(g)
            True
            >>> g = GlyphCoordinates([(0,.5), (0,0)])
            >>> bool(g)
            True
            """
            return bool(self._a)

        __nonzero__ = __bool__

    if __name__ == "__main__":
        import doctest, sys

        sys.exit(doctest.testmod().failed)