# Source code for fontTools.misc.psCharStrings

    """psCharStrings.py -- module implementing various kinds of CharStrings:
    CFF dictionary data and Type1/Type2 CharStrings.
    """

    from fontTools.misc.fixedTools import (
    	fixedToFloat, floatToFixed, floatToFixedToStr, strToFixedToFloat,
    )
    from fontTools.misc.textTools import bytechr, byteord, bytesjoin, strjoin
    from fontTools.pens.boundsPen import BoundsPen
    import struct
    import logging

    log = logging.getLogger(__name__)

    def read_operator(self, b0, data, index):
    	if b0 == 12:
    		op = (b0, byteord(data[index]))
    		index = index+1
    	else:
    		op = b0
    	try:
    		operator = self.operators[op]
    	except KeyError:
    		return None, index
    	value = self.handle_operator(operator)
    	return value, index

    def read_byte(self, b0, data, index):
    	return b0 - 139, index

    def read_smallInt1(self, b0, data, index):
    	b1 = byteord(data[index])
    	return (b0-247)*256 + b1 + 108, index+1

    def read_smallInt2(self, b0, data, index):
    	b1 = byteord(data[index])
    	return -(b0-251)*256 - b1 - 108, index+1

    def read_shortInt(self, b0, data, index):
    	value, = struct.unpack(">h", data[index:index+2])
    	return value, index+2

    def read_longInt(self, b0, data, index):
    	value, = struct.unpack(">l", data[index:index+4])
    	return value, index+4

    def read_fixed1616(self, b0, data, index):
    	value, = struct.unpack(">l", data[index:index+4])
    	return fixedToFloat(value, precisionBits=16), index+4

    def read_reserved(self, b0, data, index):
    	assert NotImplementedError
    	return NotImplemented, index

    def read_realNumber(self, b0, data, index):
    	number = ''
    	while True:
    		b = byteord(data[index])
    		index = index + 1
    		nibble0 = (b & 0xf0) >> 4
    		nibble1 = b & 0x0f
    		if nibble0 == 0xf:
    			break
    		number = number + realNibbles[nibble0]
    		if nibble1 == 0xf:
    			break
    		number = number + realNibbles[nibble1]
    	return float(number), index

    t1OperandEncoding = [None] * 256
    t1OperandEncoding[0:32] = (32) * [read_operator]
    t1OperandEncoding[32:247] = (247 - 32) * [read_byte]
    t1OperandEncoding[247:251] = (251 - 247) * [read_smallInt1]
    t1OperandEncoding[251:255] = (255 - 251) * [read_smallInt2]
    t1OperandEncoding[255] = read_longInt
    assert len(t1OperandEncoding) == 256

    t2OperandEncoding = t1OperandEncoding[:]
    t2OperandEncoding[28] = read_shortInt
    t2OperandEncoding[255] = read_fixed1616

    cffDictOperandEncoding = t2OperandEncoding[:]
    cffDictOperandEncoding[29] = read_longInt
    cffDictOperandEncoding[30] = read_realNumber
    cffDictOperandEncoding[255] = read_reserved

    realNibbles = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    		'.', 'E', 'E-', None, '-']
    realNibblesDict = {v:i for i,v in enumerate(realNibbles)}

    maxOpStack = 193

    def buildOperatorDict(operatorList):
    	oper = {}
    	opc = {}
    	for item in operatorList:
    		if len(item) == 2:
    			oper[item[0]] = item[1]
    		else:
    			oper[item[0]] = item[1:]
    		if isinstance(item[0], tuple):
    			opc[item[1]] = item[0]
    		else:
    			opc[item[1]] = (item[0],)
    	return oper, opc

    t2Operators = [
    #	opcode		name
    	(1,		'hstem'),
    	(3,		'vstem'),
    	(4,		'vmoveto'),
    	(5,		'rlineto'),
    	(6,		'hlineto'),
    	(7,		'vlineto'),
    	(8,		'rrcurveto'),
    	(10,		'callsubr'),
    	(11,		'return'),
    	(14,		'endchar'),
    	(15,		'vsindex'),
    	(16,		'blend'),
    	(18,		'hstemhm'),
    	(19,		'hintmask'),
    	(20,		'cntrmask'),
    	(21,		'rmoveto'),
    	(22,		'hmoveto'),
    	(23,		'vstemhm'),
    	(24,		'rcurveline'),
    	(25,		'rlinecurve'),
    	(26,		'vvcurveto'),
    	(27,		'hhcurveto'),
    #	(28,		'shortint'),  # not really an operator
    	(29,		'callgsubr'),
    	(30,		'vhcurveto'),
    	(31,		'hvcurveto'),
    	((12, 0),	'ignore'),	# dotsection. Yes, there a few very early OTF/CFF
    							# fonts with this deprecated operator. Just ignore it.
    	((12, 3),	'and'),
    	((12, 4),	'or'),
    	((12, 5),	'not'),
    	((12, 8),	'store'),
    	((12, 9),	'abs'),
    	((12, 10),	'add'),
    	((12, 11),	'sub'),
    	((12, 12),	'div'),
    	((12, 13),	'load'),
    	((12, 14),	'neg'),
    	((12, 15),	'eq'),
    	((12, 18),	'drop'),
    	((12, 20),	'put'),
    	((12, 21),	'get'),
    	((12, 22),	'ifelse'),
    	((12, 23),	'random'),
    	((12, 24),	'mul'),
    	((12, 26),	'sqrt'),
    	((12, 27),	'dup'),
    	((12, 28),	'exch'),
    	((12, 29),	'index'),
    	((12, 30),	'roll'),
    	((12, 34),	'hflex'),
    	((12, 35),	'flex'),
    	((12, 36),	'hflex1'),
    	((12, 37),	'flex1'),
    ]

    def getIntEncoder(format):
    	if format == "cff":
    		fourByteOp = bytechr(29)
    	elif format == "t1":
    		fourByteOp = bytechr(255)
    	else:
    		assert format == "t2"
    		fourByteOp = None

    	def encodeInt(value, fourByteOp=fourByteOp, bytechr=bytechr,
    			pack=struct.pack, unpack=struct.unpack):
    		if -107 <= value <= 107:
    			code = bytechr(value + 139)
    		elif 108 <= value <= 1131:
    			value = value - 108
    			code = bytechr((value >> 8) + 247) + bytechr(value & 0xFF)
    		elif -1131 <= value <= -108:
    			value = -value - 108
    			code = bytechr((value >> 8) + 251) + bytechr(value & 0xFF)
    		elif fourByteOp is None:
    			# T2 only supports 2 byte ints
    			if -32768 <= value <= 32767:
    				code = bytechr(28) + pack(">h", value)
    			else:
    				# Backwards compatible hack: due to a previous bug in FontTools,
    				# 16.16 fixed numbers were written out as 4-byte ints. When
    				# these numbers were small, they were wrongly written back as
    				# small ints instead of 4-byte ints, breaking round-tripping.
    				# This here workaround doesn't do it any better, since we can't
    				# distinguish anymore between small ints that were supposed to
    				# be small fixed numbers and small ints that were just small
    				# ints. Hence the warning.
    				log.warning("4-byte T2 number got passed to the "
    					"IntType handler. This should happen only when reading in "
    					"old XML files.\n")
    				code = bytechr(255) + pack(">l", value)
    		else:
    			code = fourByteOp + pack(">l", value)
    		return code

    	return encodeInt

    encodeIntCFF = getIntEncoder("cff")
    encodeIntT1 = getIntEncoder("t1")
    encodeIntT2 = getIntEncoder("t2")

    def encodeFixed(f, pack=struct.pack):
    	"""For T2 only"""
    	value = floatToFixed(f, precisionBits=16)
    	if value & 0xFFFF == 0:  # check if the fractional part is zero
    		return encodeIntT2(value >> 16)  # encode only the integer part
    	else:
    		return b"\xff" + pack(">l", value)  # encode the entire fixed point value

    realZeroBytes = bytechr(30) + bytechr(0xf)

    def encodeFloat(f):
    	# For CFF only, used in cffLib
    	if f == 0.0: # 0.0 == +0.0 == -0.0
    		return realZeroBytes
    	# Note: 14 decimal digits seems to be the limitation for CFF real numbers
    	# in macOS. However, we use 8 here to match the implementation of AFDKO.
    	s = "%.8G" % f
    	if s[:2] == "0.":
    		s = s[1:]
    	elif s[:3] == "-0.":
    		s = "-" + s[2:]
    	nibbles = []
    	while s:
    		c = s[0]
    		s = s[1:]
    		if c == "E":
    			c2 = s[:1]
    			if c2 == "-":
    				s = s[1:]
    				c = "E-"
    			elif c2 == "+":
    				s = s[1:]
    		nibbles.append(realNibblesDict[c])
    	nibbles.append(0xf)
    	if len(nibbles) % 2:
    		nibbles.append(0xf)
    	d = bytechr(30)
    	for i in range(0, len(nibbles), 2):
    		d = d + bytechr(nibbles[i] << 4 | nibbles[i+1])
    	return d

    class CharStringCompileError(Exception): pass

    class SimpleT2Decompiler(object):

    	def __init__(self, localSubrs, globalSubrs, private=None, blender=None):
    		self.localSubrs = localSubrs
    		self.localBias = calcSubrBias(localSubrs)
    		self.globalSubrs = globalSubrs
    		self.globalBias = calcSubrBias(globalSubrs)
    		self.private = private
    		self.blender = blender
    		self.reset()

    	def reset(self):
    		self.callingStack = []
    		self.operandStack = []
    		self.hintCount = 0
    		self.hintMaskBytes = 0
    		self.numRegions = 0
    		self.vsIndex = 0

    	def execute(self, charString):
    		self.callingStack.append(charString)
    		needsDecompilation = charString.needsDecompilation()
    		if needsDecompilation:
    			program = []
    			pushToProgram = program.append
    		else:
    			pushToProgram = lambda x: None
    		pushToStack = self.operandStack.append
    		index = 0
    		while True:
    			token, isOperator, index = charString.getToken(index)
    			if token is None:
    				break  # we're done!
    			pushToProgram(token)
    			if isOperator:
    				handlerName = "op_" + token
    				handler = getattr(self, handlerName, None)
    				if handler is not None:
    					rv = handler(index)
    					if rv:
    						hintMaskBytes, index = rv
    						pushToProgram(hintMaskBytes)
    				else:
    					self.popall()
    			else:
    				pushToStack(token)
    		if needsDecompilation:
    			charString.setProgram(program)
    		del self.callingStack[-1]

    	def pop(self):
    		value = self.operandStack[-1]
    		del self.operandStack[-1]
    		return value

    	def popall(self):
    		stack = self.operandStack[:]
    		self.operandStack[:] = []
    		return stack

    	def push(self, value):
    		self.operandStack.append(value)

    	def op_return(self, index):
    		if self.operandStack:
    			pass

    	def op_endchar(self, index):
    		pass

    	def op_ignore(self, index):
    		pass

    	def op_callsubr(self, index):
    		subrIndex = self.pop()
    		subr = self.localSubrs[subrIndex+self.localBias]
    		self.execute(subr)

    	def op_callgsubr(self, index):
    		subrIndex = self.pop()
    		subr = self.globalSubrs[subrIndex+self.globalBias]
    		self.execute(subr)

    	def op_hstem(self, index):
    		self.countHints()
    	def op_vstem(self, index):
    		self.countHints()
    	def op_hstemhm(self, index):
    		self.countHints()
    	def op_vstemhm(self, index):
    		self.countHints()

    	def op_hintmask(self, index):
    		if not self.hintMaskBytes:
    			self.countHints()
    			self.hintMaskBytes = (self.hintCount + 7) // 8
    		hintMaskBytes, index = self.callingStack[-1].getBytes(index, self.hintMaskBytes)
    		return hintMaskBytes, index

    	op_cntrmask = op_hintmask

    	def countHints(self):
    		args = self.popall()
    		self.hintCount = self.hintCount + len(args) // 2

    	# misc
    	def op_and(self, index):
    		raise NotImplementedError
    	def op_or(self, index):
    		raise NotImplementedError
    	def op_not(self, index):
    		raise NotImplementedError
    	def op_store(self, index):
    		raise NotImplementedError
    	def op_abs(self, index):
    		raise NotImplementedError
    	def op_add(self, index):
    		raise NotImplementedError
    	def op_sub(self, index):
    		raise NotImplementedError
    	def op_div(self, index):
    		raise NotImplementedError
    	def op_load(self, index):
    		raise NotImplementedError
    	def op_neg(self, index):
    		raise NotImplementedError
    	def op_eq(self, index):
    		raise NotImplementedError
    	def op_drop(self, index):
    		raise NotImplementedError
    	def op_put(self, index):
    		raise NotImplementedError
    	def op_get(self, index):
    		raise NotImplementedError
    	def op_ifelse(self, index):
    		raise NotImplementedError
    	def op_random(self, index):
    		raise NotImplementedError
    	def op_mul(self, index):
    		raise NotImplementedError
    	def op_sqrt(self, index):
    		raise NotImplementedError
    	def op_dup(self, index):
    		raise NotImplementedError
    	def op_exch(self, index):
    		raise NotImplementedError
    	def op_index(self, index):
    		raise NotImplementedError
    	def op_roll(self, index):
    		raise NotImplementedError

    	def op_blend(self, index):
    		if self.numRegions == 0:
    			self.numRegions = self.private.getNumRegions()
    		numBlends = self.pop()
    		numOps = numBlends * (self.numRegions + 1)
    		if self.blender is None:
    			del self.operandStack[-(numOps-numBlends):] # Leave the default operands on the stack.
    		else:
    			argi = len(self.operandStack) - numOps
    			end_args = tuplei = argi + numBlends
    			while argi < end_args:
    				next_ti = tuplei + self.numRegions
    				deltas = self.operandStack[tuplei:next_ti]
    				delta = self.blender(self.vsIndex, deltas)
    				self.operandStack[argi] += delta
    				tuplei = next_ti
    				argi += 1
    			self.operandStack[end_args:] = []

    	def op_vsindex(self, index):
    		vi = self.pop()
    		self.vsIndex = vi
    		self.numRegions = self.private.getNumRegions(vi)

    t1Operators = [
    #	opcode		name
    	(1,		'hstem'),
    	(3,		'vstem'),
    	(4,		'vmoveto'),
    	(5,		'rlineto'),
    	(6,		'hlineto'),
    	(7,		'vlineto'),
    	(8,		'rrcurveto'),
    	(9,		'closepath'),
    	(10,		'callsubr'),
    	(11,		'return'),
    	(13,		'hsbw'),
    	(14,		'endchar'),
    	(21,		'rmoveto'),
    	(22,		'hmoveto'),
    	(30,		'vhcurveto'),
    	(31,		'hvcurveto'),
    	((12, 0),	'dotsection'),
    	((12, 1),	'vstem3'),
    	((12, 2),	'hstem3'),
    	((12, 6),	'seac'),
    	((12, 7),	'sbw'),
    	((12, 12),	'div'),
    	((12, 16),	'callothersubr'),
    	((12, 17),	'pop'),
    	((12, 33),	'setcurrentpoint'),
    ]

    class T2WidthExtractor(SimpleT2Decompiler):

    	def __init__(self, localSubrs, globalSubrs, nominalWidthX, defaultWidthX, private=None, blender=None):
    		SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs, private, blender)
    		self.nominalWidthX = nominalWidthX
    		self.defaultWidthX = defaultWidthX

    	def reset(self):
    		SimpleT2Decompiler.reset(self)
    		self.gotWidth = 0
    		self.width = 0

    	def popallWidth(self, evenOdd=0):
    		args = self.popall()
    		if not self.gotWidth:
    			if evenOdd ^ (len(args) % 2):
    				# For CFF2 charstrings, this should never happen
    				assert self.defaultWidthX is not None, "CFF2 CharStrings must not have an initial width value"
    				self.width = self.nominalWidthX + args[0]
    				args = args[1:]
    			else:
    				self.width = self.defaultWidthX
    			self.gotWidth = 1
    		return args

    	def countHints(self):
    		args = self.popallWidth()
    		self.hintCount = self.hintCount + len(args) // 2

    	def op_rmoveto(self, index):
    		self.popallWidth()

    	def op_hmoveto(self, index):
    		self.popallWidth(1)

    	def op_vmoveto(self, index):
    		self.popallWidth(1)

    	def op_endchar(self, index):
    		self.popallWidth()

    class T2OutlineExtractor(T2WidthExtractor):

    	def __init__(self, pen, localSubrs, globalSubrs, nominalWidthX, defaultWidthX, private=None, blender=None):
    		T2WidthExtractor.__init__(
    			self, localSubrs, globalSubrs, nominalWidthX, defaultWidthX, private, blender)
    		self.pen = pen
    		self.subrLevel = 0

    	def reset(self):
    		T2WidthExtractor.reset(self)
    		self.currentPoint = (0, 0)
    		self.sawMoveTo = 0
    		self.subrLevel = 0

    	def execute(self, charString):
    		self.subrLevel += 1
    		super().execute(charString)
    		self.subrLevel -= 1
    		if self.subrLevel == 0:
    			self.endPath()

    	def _nextPoint(self, point):
    		x, y = self.currentPoint
    		point = x + point[0], y + point[1]
    		self.currentPoint = point
    		return point

    	def rMoveTo(self, point):
    		self.pen.moveTo(self._nextPoint(point))
    		self.sawMoveTo = 1

    	def rLineTo(self, point):
    		if not self.sawMoveTo:
    			self.rMoveTo((0, 0))
    		self.pen.lineTo(self._nextPoint(point))

    	def rCurveTo(self, pt1, pt2, pt3):
    		if not self.sawMoveTo:
    			self.rMoveTo((0, 0))
    		nextPoint = self._nextPoint
    		self.pen.curveTo(nextPoint(pt1), nextPoint(pt2), nextPoint(pt3))

    	def closePath(self):
    		if self.sawMoveTo:
    			self.pen.closePath()
    		self.sawMoveTo = 0

    	def endPath(self):
    		# In T2 there are no open paths, so always do a closePath when
    		# finishing a sub path. We avoid spurious calls to closePath()
    		# because its a real T1 op we're emulating in T2 whereas
    		# endPath() is just a means to that emulation
    		if self.sawMoveTo:
    			self.closePath()

    	#
    	# hint operators
    	#
    	#def op_hstem(self, index):
    	#	self.countHints()
    	#def op_vstem(self, index):
    	#	self.countHints()
    	#def op_hstemhm(self, index):
    	#	self.countHints()
    	#def op_vstemhm(self, index):
    	#	self.countHints()
    	#def op_hintmask(self, index):
    	#	self.countHints()
    	#def op_cntrmask(self, index):
    	#	self.countHints()

    	#
    	# path constructors, moveto
    	#
    	def op_rmoveto(self, index):
    		self.endPath()
    		self.rMoveTo(self.popallWidth())
    	def op_hmoveto(self, index):
    		self.endPath()
    		self.rMoveTo((self.popallWidth(1)[0], 0))
    	def op_vmoveto(self, index):
    		self.endPath()
    		self.rMoveTo((0, self.popallWidth(1)[0]))
    	def op_endchar(self, index):
    		self.endPath()
    		args = self.popallWidth()
    		if args:
    			from fontTools.encodings.StandardEncoding import StandardEncoding
    			# endchar can do seac accent bulding; The T2 spec says it's deprecated,
    			# but recent software that shall remain nameless does output it.
    			adx, ady, bchar, achar = args
    			baseGlyph = StandardEncoding[bchar]
    			self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0))
    			accentGlyph = StandardEncoding[achar]
    			self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady))

    	#
    	# path constructors, lines
    	#
    	def op_rlineto(self, index):
    		args = self.popall()
    		for i in range(0, len(args), 2):
    			point = args[i:i+2]
    			self.rLineTo(point)

    	def op_hlineto(self, index):
    		self.alternatingLineto(1)
    	def op_vlineto(self, index):
    		self.alternatingLineto(0)

    	#
    	# path constructors, curves
    	#
    	def op_rrcurveto(self, index):
    		"""{dxa dya dxb dyb dxc dyc}+ rrcurveto"""
    		args = self.popall()
    		for i in range(0, len(args), 6):
    			dxa, dya, dxb, dyb, dxc, dyc, = args[i:i+6]
    			self.rCurveTo((dxa, dya), (dxb, dyb), (dxc, dyc))

    	def op_rcurveline(self, index):
    		"""{dxa dya dxb dyb dxc dyc}+ dxd dyd rcurveline"""
    		args = self.popall()
    		for i in range(0, len(args)-2, 6):
    			dxb, dyb, dxc, dyc, dxd, dyd = args[i:i+6]
    			self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd))
    		self.rLineTo(args[-2:])

    	def op_rlinecurve(self, index):
    		"""{dxa dya}+ dxb dyb dxc dyc dxd dyd rlinecurve"""
    		args = self.popall()
    		lineArgs = args[:-6]
    		for i in range(0, len(lineArgs), 2):
    			self.rLineTo(lineArgs[i:i+2])
    		dxb, dyb, dxc, dyc, dxd, dyd = args[-6:]
    		self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd))

    	def op_vvcurveto(self, index):
    		"dx1? {dya dxb dyb dyc}+ vvcurveto"
    		args = self.popall()
    		if len(args) % 2:
    			dx1 = args[0]
    			args = args[1:]
    		else:
    			dx1 = 0
    		for i in range(0, len(args), 4):
    			dya, dxb, dyb, dyc = args[i:i+4]
    			self.rCurveTo((dx1, dya), (dxb, dyb), (0, dyc))
    			dx1 = 0

    	def op_hhcurveto(self, index):
    		"""dy1? {dxa dxb dyb dxc}+ hhcurveto"""
    		args = self.popall()
    		if len(args) % 2:
    			dy1 = args[0]
    			args = args[1:]
    		else:
    			dy1 = 0
    		for i in range(0, len(args), 4):
    			dxa, dxb, dyb, dxc = args[i:i+4]
    			self.rCurveTo((dxa, dy1), (dxb, dyb), (dxc, 0))
    			dy1 = 0

    	def op_vhcurveto(self, index):
    		"""dy1 dx2 dy2 dx3 {dxa dxb dyb dyc dyd dxe dye dxf}* dyf? vhcurveto (30)
    		{dya dxb dyb dxc dxd dxe dye dyf}+ dxf? vhcurveto
    		"""
    		args = self.popall()
    		while args:
    			args = self.vcurveto(args)
    			if args:
    				args = self.hcurveto(args)

    	def op_hvcurveto(self, index):
    		"""dx1 dx2 dy2 dy3 {dya dxb dyb dxc dxd dxe dye dyf}* dxf?
    		{dxa dxb dyb dyc dyd dxe dye dxf}+ dyf?
    		"""
    		args = self.popall()
    		while args:
    			args = self.hcurveto(args)
    			if args:
    				args = self.vcurveto(args)

    	#
    	# path constructors, flex
    	#
    	def op_hflex(self, index):
    		dx1, dx2, dy2, dx3, dx4, dx5, dx6 = self.popall()
    		dy1 = dy3 = dy4 = dy6 = 0
    		dy5 = -dy2
    		self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
    		self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
    	def op_flex(self, index):
    		dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, dx6, dy6, fd = self.popall()
    		self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
    		self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
    	def op_hflex1(self, index):
    		dx1, dy1, dx2, dy2, dx3, dx4, dx5, dy5, dx6 = self.popall()
    		dy3 = dy4 = 0
    		dy6 = -(dy1 + dy2 + dy3 + dy4 + dy5)

    		self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
    		self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
    	def op_flex1(self, index):
    		dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, d6 = self.popall()
    		dx = dx1 + dx2 + dx3 + dx4 + dx5
    		dy = dy1 + dy2 + dy3 + dy4 + dy5
    		if abs(dx) > abs(dy):
    			dx6 = d6
    			dy6 = -dy
    		else:
    			dx6 = -dx
    			dy6 = d6
    		self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
    		self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))

    	# misc
    	def op_and(self, index):
    		raise NotImplementedError
    	def op_or(self, index):
    		raise NotImplementedError
    	def op_not(self, index):
    		raise NotImplementedError
    	def op_store(self, index):
    		raise NotImplementedError
    	def op_abs(self, index):
    		raise NotImplementedError
    	def op_add(self, index):
    		raise NotImplementedError
    	def op_sub(self, index):
    		raise NotImplementedError
    	def op_div(self, index):
    		num2 = self.pop()
    		num1 = self.pop()
    		d1 = num1//num2
    		d2 = num1/num2
    		if d1 == d2:
    			self.push(d1)
    		else:
    			self.push(d2)
    	def op_load(self, index):
    		raise NotImplementedError
    	def op_neg(self, index):
    		raise NotImplementedError
    	def op_eq(self, index):
    		raise NotImplementedError
    	def op_drop(self, index):
    		raise NotImplementedError
    	def op_put(self, index):
    		raise NotImplementedError
    	def op_get(self, index):
    		raise NotImplementedError
    	def op_ifelse(self, index):
    		raise NotImplementedError
    	def op_random(self, index):
    		raise NotImplementedError
    	def op_mul(self, index):
    		raise NotImplementedError
    	def op_sqrt(self, index):
    		raise NotImplementedError
    	def op_dup(self, index):
    		raise NotImplementedError
    	def op_exch(self, index):
    		raise NotImplementedError
    	def op_index(self, index):
    		raise NotImplementedError
    	def op_roll(self, index):
    		raise NotImplementedError

    	#
    	# miscellaneous helpers
    	#
    	def alternatingLineto(self, isHorizontal):
    		args = self.popall()
    		for arg in args:
    			if isHorizontal:
    				point = (arg, 0)
    			else:
    				point = (0, arg)
    			self.rLineTo(point)
    			isHorizontal = not isHorizontal

    	def vcurveto(self, args):
    		dya, dxb, dyb, dxc = args[:4]
    		args = args[4:]
    		if len(args) == 1:
    			dyc = args[0]
    			args = []
    		else:
    			dyc = 0
    		self.rCurveTo((0, dya), (dxb, dyb), (dxc, dyc))
    		return args

    	def hcurveto(self, args):
    		dxa, dxb, dyb, dyc = args[:4]
    		args = args[4:]
    		if len(args) == 1:
    			dxc = args[0]
    			args = []
    		else:
    			dxc = 0
    		self.rCurveTo((dxa, 0), (dxb, dyb), (dxc, dyc))
    		return args

    class T1OutlineExtractor(T2OutlineExtractor):

    	def __init__(self, pen, subrs):
    		self.pen = pen
    		self.subrs = subrs
    		self.reset()

    	def reset(self):
    		self.flexing = 0
    		self.width = 0
    		self.sbx = 0
    		T2OutlineExtractor.reset(self)

    	def endPath(self):
    		if self.sawMoveTo:
    			self.pen.endPath()
    		self.sawMoveTo = 0

    	def popallWidth(self, evenOdd=0):
    		return self.popall()

    	def exch(self):
    		stack = self.operandStack
    		stack[-1], stack[-2] = stack[-2], stack[-1]

    	#
    	# path constructors
    	#
    	def op_rmoveto(self, index):
    		if self.flexing:
    			return
    		self.endPath()
    		self.rMoveTo(self.popall())
    	def op_hmoveto(self, index):
    		if self.flexing:
    			# We must add a parameter to the stack if we are flexing
    			self.push(0)
    			return
    		self.endPath()
    		self.rMoveTo((self.popall()[0], 0))
    	def op_vmoveto(self, index):
    		if self.flexing:
    			# We must add a parameter to the stack if we are flexing
    			self.push(0)
    			self.exch()
    			return
    		self.endPath()
    		self.rMoveTo((0, self.popall()[0]))
    	def op_closepath(self, index):
    		self.closePath()
    	def op_setcurrentpoint(self, index):
    		args = self.popall()
    		x, y = args
    		self.currentPoint = x, y

    	def op_endchar(self, index):
    		self.endPath()

    	def op_hsbw(self, index):
    		sbx, wx = self.popall()
    		self.width = wx
    		self.sbx = sbx
    		self.currentPoint = sbx, self.currentPoint[1]
    	def op_sbw(self, index):
    		self.popall()  # XXX

    	#
    	def op_callsubr(self, index):
    		subrIndex = self.pop()
    		subr = self.subrs[subrIndex]
    		self.execute(subr)
    	def op_callothersubr(self, index):
    		subrIndex = self.pop()
    		nArgs = self.pop()
    		#print nArgs, subrIndex, "callothersubr"
    		if subrIndex == 0 and nArgs == 3:
    			self.doFlex()
    			self.flexing = 0
    		elif subrIndex == 1 and nArgs == 0:
    			self.flexing = 1
    		# ignore...
    	def op_pop(self, index):
    		pass  # ignore...

    	def doFlex(self):
    		finaly = self.pop()
    		finalx = self.pop()
    		self.pop()	# flex height is unused

    		p3y = self.pop()
    		p3x = self.pop()
    		bcp4y = self.pop()
    		bcp4x = self.pop()
    		bcp3y = self.pop()
    		bcp3x = self.pop()
    		p2y = self.pop()
    		p2x = self.pop()
    		bcp2y = self.pop()
    		bcp2x = self.pop()
    		bcp1y = self.pop()
    		bcp1x = self.pop()
    		rpy = self.pop()
    		rpx = self.pop()

    		# call rrcurveto
    		self.push(bcp1x+rpx)
    		self.push(bcp1y+rpy)
    		self.push(bcp2x)
    		self.push(bcp2y)
    		self.push(p2x)
    		self.push(p2y)
    		self.op_rrcurveto(None)

    		# call rrcurveto
    		self.push(bcp3x)
    		self.push(bcp3y)
    		self.push(bcp4x)
    		self.push(bcp4y)
    		self.push(p3x)
    		self.push(p3y)
    		self.op_rrcurveto(None)

    		# Push back final coords so subr 0 can find them
    		self.push(finalx)
    		self.push(finaly)

    	def op_dotsection(self, index):
    		self.popall()  # XXX
    	def op_hstem3(self, index):
    		self.popall()  # XXX
    	def op_seac(self, index):
    		"asb adx ady bchar achar seac"
    		from fontTools.encodings.StandardEncoding import StandardEncoding
    		asb, adx, ady, bchar, achar = self.popall()
    		baseGlyph = StandardEncoding[bchar]
    		self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0))
    		accentGlyph = StandardEncoding[achar]
    		adx = adx + self.sbx - asb  # seac weirdness
    		self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady))
    	def op_vstem3(self, index):
    		self.popall()  # XXX

    class T2CharString(object):

    	operandEncoding = t2OperandEncoding
    	operators, opcodes = buildOperatorDict(t2Operators)
    	decompilerClass = SimpleT2Decompiler
    	outlineExtractor = T2OutlineExtractor

    	def __init__(self, bytecode=None, program=None, private=None, globalSubrs=None):
    		if program is None:
    			program = []
    		self.bytecode = bytecode
    		self.program = program
    		self.private = private
    		self.globalSubrs = globalSubrs if globalSubrs is not None else []
    		self._cur_vsindex = None

    	def getNumRegions(self, vsindex=None):
    		pd = self.private
    		assert(pd is not None)
    		if vsindex is not None:
    			self._cur_vsindex = vsindex
    		elif self._cur_vsindex is None:
    			self._cur_vsindex = pd.vsindex if hasattr(pd, 'vsindex') else 0
    		return pd.getNumRegions(self._cur_vsindex)

    	def __repr__(self):
    		if self.bytecode is None:
    			return "<%s (source) at %x>" % (self.__class__.__name__, id(self))
    		else:
    			return "<%s (bytecode) at %x>" % (self.__class__.__name__, id(self))

    	def getIntEncoder(self):
    		return encodeIntT2

    	def getFixedEncoder(self):
    		return encodeFixed

    	def decompile(self):
    		if not self.needsDecompilation():
    			return
    		subrs = getattr(self.private, "Subrs", [])
    		decompiler = self.decompilerClass(subrs, self.globalSubrs, self.private)
    		decompiler.execute(self)

    	def draw(self, pen, blender=None):
    		subrs = getattr(self.private, "Subrs", [])
    		extractor = self.outlineExtractor(pen, subrs, self.globalSubrs,
    				self.private.nominalWidthX, self.private.defaultWidthX,
    				self.private, blender)
    		extractor.execute(self)
    		self.width = extractor.width

    	def calcBounds(self, glyphSet):
    		boundsPen = BoundsPen(glyphSet)
    		self.draw(boundsPen)
    		return boundsPen.bounds

    	def compile(self, isCFF2=False):
    		if self.bytecode is not None:
    			return
    		opcodes = self.opcodes
    		program = self.program

    		if isCFF2:
    			# If present, remove return and endchar operators.
    			if program and program[-1] in ("return", "endchar"):
    				program = program[:-1]
    		elif program and not isinstance(program[-1], str):
    			raise CharStringCompileError(
    				"T2CharString or Subr has items on the stack after last operator."
    			)

    		bytecode = []
    		encodeInt = self.getIntEncoder()
    		encodeFixed = self.getFixedEncoder()
    		i = 0
    		end = len(program)
    		while i < end:
    			token = program[i]
    			i = i + 1
    			if isinstance(token, str):
    				try:
    					bytecode.extend(bytechr(b) for b in opcodes[token])
    				except KeyError:
    					raise CharStringCompileError("illegal operator: %s" % token)
    				if token in ('hintmask', 'cntrmask'):
    					bytecode.append(program[i])  # hint mask
    					i = i + 1
    			elif isinstance(token, int):
    				bytecode.append(encodeInt(token))
    			elif isinstance(token, float):
    				bytecode.append(encodeFixed(token))
    			else:
    				assert 0, "unsupported type: %s" % type(token)
    		try:
    			bytecode = bytesjoin(bytecode)
    		except TypeError:
    			log.error(bytecode)
    			raise
    		self.setBytecode(bytecode)

    	def needsDecompilation(self):
    		return self.bytecode is not None

    	def setProgram(self, program):
    		self.program = program
    		self.bytecode = None

    	def setBytecode(self, bytecode):
    		self.bytecode = bytecode
    		self.program = None

    	def getToken(self, index,
    			len=len, byteord=byteord, isinstance=isinstance):
    		if self.bytecode is not None:
    			if index >= len(self.bytecode):
    				return None, 0, 0
    			b0 = byteord(self.bytecode[index])
    			index = index + 1
    			handler = self.operandEncoding[b0]
    			token, index = handler(self, b0, self.bytecode, index)
    		else:
    			if index >= len(self.program):
    				return None, 0, 0
    			token = self.program[index]
    			index = index + 1
    		isOperator = isinstance(token, str)
    		return token, isOperator, index

    	def getBytes(self, index, nBytes):
    		if self.bytecode is not None:
    			newIndex = index + nBytes
    			bytes = self.bytecode[index:newIndex]
    			index = newIndex
    		else:
    			bytes = self.program[index]
    			index = index + 1
    		assert len(bytes) == nBytes
    		return bytes, index

    	def handle_operator(self, operator):
    		return operator

    	def toXML(self, xmlWriter, ttFont=None):
    		from fontTools.misc.textTools import num2binary
    		if self.bytecode is not None:
    			xmlWriter.dumphex(self.bytecode)
    		else:
    			index = 0
    			args = []
    			while True:
    				token, isOperator, index = self.getToken(index)
    				if token is None:
    					break
    				if isOperator:
    					if token in ('hintmask', 'cntrmask'):
    						hintMask, isOperator, index = self.getToken(index)
    						bits = []
    						for byte in hintMask:
    							bits.append(num2binary(byteord(byte), 8))
    						hintMask = strjoin(bits)
    						line = ' '.join(args + [token, hintMask])
    					else:
    						line = ' '.join(args + [token])
    					xmlWriter.write(line)
    					xmlWriter.newline()
    					args = []
    				else:
    					if isinstance(token, float):
    						token = floatToFixedToStr(token, precisionBits=16)
    					else:
    						token = str(token)
    					args.append(token)
    			if args:
    				# NOTE: only CFF2 charstrings/subrs can have numeric arguments on
    				# the stack after the last operator. Compiling this would fail if
    				# this is part of CFF 1.0 table.
    				line = ' '.join(args)
    				xmlWriter.write(line)

    	def fromXML(self, name, attrs, content):
    		from fontTools.misc.textTools import binary2num, readHex
    		if attrs.get("raw"):
    			self.setBytecode(readHex(content))
    			return
    		content = strjoin(content)
    		content = content.split()
    		program = []
    		end = len(content)
    		i = 0
    		while i < end:
    			token = content[i]
    			i = i + 1
    			try:
    				token = int(token)
    			except ValueError:
    				try:
    					token = strToFixedToFloat(token, precisionBits=16)
    				except ValueError:
    					program.append(token)
    					if token in ('hintmask', 'cntrmask'):
    						mask = content[i]
    						maskBytes = b""
    						for j in range(0, len(mask), 8):
    							maskBytes = maskBytes + bytechr(binary2num(mask[j:j+8]))
    						program.append(maskBytes)
    						i = i + 1
    				else:
    					program.append(token)
    			else:
    				program.append(token)
    		self.setProgram(program)

    class T1CharString(T2CharString):

    	operandEncoding = t1OperandEncoding
    	operators, opcodes = buildOperatorDict(t1Operators)

    	def __init__(self, bytecode=None, program=None, subrs=None):
    		super().__init__(bytecode, program)
    		self.subrs = subrs

    	def getIntEncoder(self):
    		return encodeIntT1

    	def getFixedEncoder(self):
    		def encodeFixed(value):
    			raise TypeError("Type 1 charstrings don't support floating point operands")

    	def decompile(self):
    		if self.bytecode is None:
    			return
    		program = []
    		index = 0
    		while True:
    			token, isOperator, index = self.getToken(index)
    			if token is None:
    				break
    			program.append(token)
    		self.setProgram(program)

    	def draw(self, pen):
    		extractor = T1OutlineExtractor(pen, self.subrs)
    		extractor.execute(self)
    		self.width = extractor.width

    class DictDecompiler(object):

    	operandEncoding = cffDictOperandEncoding

    	def __init__(self, strings, parent=None):
    		self.stack = []
    		self.strings = strings
    		self.dict = {}
    		self.parent = parent

    	def getDict(self):
    		assert len(self.stack) == 0, "non-empty stack"
    		return self.dict

    	def decompile(self, data):
    		index = 0
    		lenData = len(data)
    		push = self.stack.append
    		while index < lenData:
    			b0 = byteord(data[index])
    			index = index + 1
    			handler = self.operandEncoding[b0]
    			value, index = handler(self, b0, data, index)
    			if value is not None:
    				push(value)
    	def pop(self):
    		value = self.stack[-1]
    		del self.stack[-1]
    		return value

    	def popall(self):
    		args = self.stack[:]
    		del self.stack[:]
    		return args

    	def handle_operator(self, operator):
    		operator, argType = operator
    		if isinstance(argType, tuple):
    			value = ()
    			for i in range(len(argType)-1, -1, -1):
    				arg = argType[i]
    				arghandler = getattr(self, "arg_" + arg)
    				value = (arghandler(operator),) + value
    		else:
    			arghandler = getattr(self, "arg_" + argType)
    			value = arghandler(operator)
    		if operator == "blend":
    			self.stack.extend(value)
    		else:
    			self.dict[operator] = value

    	def arg_number(self, name):
    		if isinstance(self.stack[0], list):
    			out = self.arg_blend_number(self.stack)
    		else:
    			out = self.pop()
    		return out

    	def arg_blend_number(self, name):
    		out = []
    		blendArgs = self.pop()
    		numMasters = len(blendArgs)
    		out.append(blendArgs)
    		out.append("blend")
    		dummy = self.popall()
    		return blendArgs

    	def arg_SID(self, name):
    		return self.strings[self.pop()]
    	def arg_array(self, name):
    		return self.popall()
    	def arg_blendList(self, name):
    		"""
    		There may be non-blend args at the top of the stack. We first calculate
    		where the blend args start in the stack. These are the last
    		numMasters*numBlends) +1 args.
    		The blend args starts with numMasters relative coordinate values, the  BlueValues in the list from the default master font. This is followed by
    		numBlends list of values. Each of  value in one of these lists is the
    		Variable Font delta for the matching region.

    		We re-arrange this to be a list of numMaster entries. Each entry starts with the corresponding default font relative value, and is followed by
    		the delta values. We then convert the default values, the first item in each entry, to an absolute value.
    		"""
    		vsindex = self.dict.get('vsindex', 0)
    		numMasters = self.parent.getNumRegions(vsindex) + 1 # only a PrivateDict has blended ops.
    		numBlends = self.pop()
    		args = self.popall()
    		numArgs = len(args)
    		# The spec says that there should be no non-blended Blue Values,.
    		assert(numArgs == numMasters * numBlends)
    		value = [None]*numBlends
    		numDeltas = numMasters-1
    		i = 0
    		prevVal = 0
    		while i < numBlends:
    			newVal = args[i] + prevVal
    			prevVal = newVal
    			masterOffset = numBlends + (i* numDeltas)
    			blendList = [newVal] + args[masterOffset:masterOffset+numDeltas]
    			value[i] = blendList
    			i += 1
    		return value

    	def arg_delta(self, name):
    		valueList = self.popall()
    		out = []
    		if valueList and isinstance(valueList[0], list):
    			# arg_blendList() has already converted these to absolute values.
    			out = valueList
    		else:
    			current = 0
    			for v in valueList:
    				current = current + v
    				out.append(current)
    		return out

    def calcSubrBias(subrs):
    	nSubrs = len(subrs)
    	if nSubrs < 1240:
    		bias = 107
    	elif nSubrs < 33900:
    		bias = 1131
    	else:
    		bias = 32768
    	return bias