DEBUG_NONE = 0x0000
DEBUG_ENCODER = 0x0001
DEBUG_DECODER = 0x0002
DEBUG_ALL = 0xffff
FLAG_MAP = {
    'none': DEBUG_NONE,
    'encoder': DEBUG_ENCODER,
    'decoder': DEBUG_DECODER,
    'all': DEBUG_ALL
}
LOGGEE_MAP = {}
_LOG = DEBUG_NONE
        _LOG = userLogger
        _LOG = DEBUG_NONE
class Printer(object):
class Debug(object):
class Scope(object):
    def __init__(self, logger=None, handler=None, formatter=None):
    def __call__(self, msg):
    def __str__(self):
    def __init__(self, *flags, **options):
    def __str__(self):
    def __call__(self, msg):
    def __and__(self, flag):
    def __rand__(self, flag):
def setLogger(userLogger):
def registerLoggee(module, name='LOG', flags=DEBUG_NONE):
def hexdump(octets):
    def __init__(self):
    def __str__(self): return '.'.join(self._list)
    def push(self, token):
    def pop(self): class PyAsn1Error(Exception):
class ValueConstraintError(PyAsn1Error):
class SubstrateUnderrunError(PyAsn1Error):
class EndOfStreamError(SubstrateUnderrunError):
class UnsupportedSubstrateError(PyAsn1Error):
class PyAsn1UnicodeError(PyAsn1Error, UnicodeError):
class PyAsn1UnicodeDecodeError(PyAsn1UnicodeError, UnicodeDecodeError):
class PyAsn1UnicodeEncodeError(PyAsn1UnicodeError, UnicodeEncodeError):
    def __init__(self, *args, **kwargs):
    def context(self):
    def __init__(self, message, unicode_error=None): class EndOfOctets(base.SimpleAsn1Type):
    def __new__(cls, *args, **kwargs): def asSeekableStream(substrate):
    """Convert object to seekable byte-stream.

    Parameters
    ----------
    substrate: :py:class:`bytes` or :py:class:`io.IOBase` or :py:class:`univ.OctetString`

    Returns
    -------
    : :py:class:`io.IOBase`

    Raises
    ------
    : :py:class:`~pyasn1.error.PyAsn1Error`
        If the supplied substrate cannot be converted to a seekable stream.
    """
    if isinstance(substrate, io.BytesIO):
        return substrate

    elif isinstance(substrate, bytes):
        return io.BytesIO(substrate)

    elif isinstance(substrate, univ.OctetString):
        return io.BytesIO(substrate.asOctets())

    try:
        # Special case: impossible to set attributes on `file` built-in
        if _PY2 and isinstance(substrate, file):
            return io.BufferedReader(substrate)

        elif substrate.seekable():  # Will fail for most invalid types
            return substrate

        else:
            return CachingStreamWrapper(substrate)

    except AttributeError:
        raise error.UnsupportedSubstrateError(
            "Cannot convert " + substrate.__class__.__name__ +
            " to a seekable bit stream.") def isEndOfStream(substrate):
    """Check whether we have reached the end of a stream.

    Although it is more effective to read and catch exceptions, this
    function

    Parameters
    ----------
    substrate: :py:class:`IOBase`
        Stream to check

    Returns
    -------
    : :py:class:`bool`
    """
    if isinstance(substrate, io.BytesIO):
        cp = substrate.tell()
        substrate.seek(0, os.SEEK_END)
        result = substrate.tell() == cp
        substrate.seek(cp, os.SEEK_SET)
        yield result

    else:
        received = substrate.read(1)
        if received is None:
            yield

        if received:
            substrate.seek(-1, os.SEEK_CUR)

        yield not received def peekIntoStream(substrate, size=-1):
    """Peek into stream.

    Parameters
    ----------
    substrate: :py:class:`IOBase`
        Stream to read from.

    size: :py:class:`int`
        How many bytes to peek (-1 = all available)

    Returns
    -------
    : :py:class:`bytes` or :py:class:`str`
        The return type depends on Python major version
    """
    if hasattr(substrate, "peek"):
        received = substrate.peek(size)
        if received is None:
            yield

        while len(received) < size:
            yield

        yield received

    else:
        current_position = substrate.tell()
        try:
            for chunk in readFromStream(substrate, size):
                yield chunk

        finally:
            substrate.seek(current_position) def readFromStream(substrate, size=-1, context=None):
    """Read from the stream.

    Parameters
    ----------
    substrate: :py:class:`IOBase`
        Stream to read from.

    Keyword parameters
    ------------------
    size: :py:class:`int`
        How many bytes to read (-1 = all available)

    context: :py:class:`dict`
        Opaque caller context will be attached to exception objects created
        by this function.

    Yields
    ------
    : :py:class:`bytes` or :py:class:`str` or :py:class:`SubstrateUnderrunError`
        Read data or :py:class:`~pyasn1.error.SubstrateUnderrunError`
        object if no `size` bytes is readily available in the stream. The
        data type depends on Python major version

    Raises
    ------
    : :py:class:`~pyasn1.error.EndOfStreamError`
        Input stream is exhausted
    """
    while True:
        # this will block unless stream is non-blocking
        received = substrate.read(size)
        if received is None:  # non-blocking stream can do this
            yield error.SubstrateUnderrunError(context=context)

        elif not received and size != 0:  # end-of-stream
            raise error.EndOfStreamError(context=context)

        elif len(received) < size:
            substrate.seek(-len(received), os.SEEK_CUR)

            # behave like a non-blocking stream
            yield error.SubstrateUnderrunError(context=context)

        else:
            break

    yield received def from_bytes(octets, signed=False):
    if not octets:
        return 0

    value = long(b2a_hex(ensureString(octets)), 16)

    if signed and oct2int(octets[0]) & 0x80:
        return value - (1 << len(octets) * 8)

    return value class PyAsn1Error(Exception):
    """Base pyasn1 exception

    `PyAsn1Error` is the base exception class (based on
    :class:`Exception`) that represents all possible ASN.1 related
    errors.

    Parameters
    ----------
    args:
        Opaque positional parameters

    Keyword Args
    ------------
    kwargs:
        Opaque keyword parameters

    """
    def __init__(self, *args, **kwargs):
        self._args = args
        self._kwargs = kwargs

    @property
    def context(self):
        """Return exception context

        When exception object is created, the caller can supply some opaque
        context for the upper layers to better understand the cause of the
        exception.

        Returns
        -------
        : :py:class:`dict`
            Dict holding context specific data
        """
        return self._kwargs.get('context', {}) class Asn1Item(object):
class Asn1Type(Asn1Item):
class NoValue(object):
class SimpleAsn1Type(Asn1Type):
class ConstructedAsn1Type(Asn1Type):
    def getTypeId(cls, increment=1):
    def __init__(self, **kwargs):
    def __setattr__(self, name, value):
    def __str__(self):
    def readOnly(self):
    def effectiveTagSet(self):
    def tagMap(self):
    def isSameTypeWith(self, other, matchTags=True, matchConstraints=True):
    def isSuperTypeOf(self, other, matchTags=True, matchConstraints=True):
    def isNoValue(*values):
    def prettyPrint(self, scope=0):
    def getTagSet(self):
    def getEffectiveTagSet(self):
    def getTagMap(self):
    def getSubtypeSpec(self):
    def hasValue(self):
    def __new__(cls):
            def getPlug(name):
                def plug(self, *args, **kw):
    def __getattr__(self, attr):
    def __repr__(self):
    def __init__(self, value=noValue, **kwargs):
    def __repr__(self):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
        def __nonzero__(self):
        def __bool__(self):
    def __hash__(self):
    def isValue(self):
    def clone(self, value=noValue, **kwargs):
    def subtype(self, value=noValue, **kwargs):
    def prettyIn(self, value):
    def prettyOut(self, value):
    def prettyPrint(self, scope=0):
    def prettyPrintType(self, scope=0):
    def __init__(self, **kwargs):
    def _moveSizeSpec(self, **kwargs):
    def __repr__(self):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
        def __nonzero__(self):
        def __bool__(self):
    def components(self):
    def _cloneComponentValues(self, myClone, cloneValueFlag):
    def clone(self, **kwargs):
    def subtype(self, **kwargs):
    def getComponentByPosition(self, idx):
    def setComponentByPosition(self, idx, value, verifyConstraints=True):
    def setComponents(self, *args, **kwargs):
    def setDefaultComponents(self):
    def getComponentType(self):
    def verifySizeSpec(self): class AbstractCharacterString(univ.OctetString):
class NumericString(AbstractCharacterString):
class PrintableString(AbstractCharacterString):
class TeletexString(AbstractCharacterString):
class T61String(TeletexString):
class VideotexString(AbstractCharacterString):
class IA5String(AbstractCharacterString):
class GraphicString(AbstractCharacterString):
class VisibleString(AbstractCharacterString):
class ISO646String(VisibleString):
class GeneralString(AbstractCharacterString):
class UniversalString(AbstractCharacterString):
class BMPString(AbstractCharacterString):
class UTF8String(AbstractCharacterString):
        def __str__(self):
        def __unicode__(self):
        def prettyIn(self, value):
        def asOctets(self, padding=True):
        def asNumbers(self, padding=True):
        def __str__(self):
        def __bytes__(self):
        def prettyIn(self, value):
        def asOctets(self, padding=True):
        def asNumbers(self, padding=True):
    def prettyOut(self, value):
    def prettyPrint(self, scope=0):
    def __reversed__(self): class Tag(object):
class TagSet(object):
    def __init__(self, tagClass, tagFormat, tagId):
    def __repr__(self):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
    def __hash__(self):
    def __getitem__(self, idx):
    def __iter__(self):
    def __and__(self, otherTag):
    def __or__(self, otherTag):
    def tagClass(self):
    def tagFormat(self):
    def tagId(self):
    def __init__(self, baseTag=(), *superTags):
    def __repr__(self):
    def __add__(self, superTag):
    def __radd__(self, superTag):
    def __getitem__(self, i):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
    def __hash__(self):
    def __len__(self):
    def baseTag(self):
    def superTags(self):
    def tagExplicitly(self, superTag):
    def tagImplicitly(self, superTag):
    def isSuperTagSetOf(self, tagSet):
    def getBaseTag(self):
def initTagSet(tag): class TagMap(object):
    def __init__(self, presentTypes=None, skipTypes=None, defaultType=None):
    def __contains__(self, tagSet):
    def __getitem__(self, tagSet):
    def __iter__(self):
    def __repr__(self):
    def presentTypes(self):
    def skipTypes(self):
    def defaultType(self):
    def getPosMap(self):
    def getNegMap(self):
    def getDef(self): class Integer(base.SimpleAsn1Type):
class Boolean(Integer):
class SizedInteger(SizedIntegerBase):
class BitString(base.SimpleAsn1Type):
class OctetString(base.SimpleAsn1Type):
class Null(OctetString):
class ObjectIdentifier(base.SimpleAsn1Type):
class Real(base.SimpleAsn1Type):
class Enumerated(Integer):
class SequenceOfAndSetOfBase(base.ConstructedAsn1Type):
class SequenceOf(SequenceOfAndSetOfBase):
class SetOf(SequenceOfAndSetOfBase):
class SequenceAndSetBase(base.ConstructedAsn1Type):
    class DynamicNames(object):
class Sequence(SequenceAndSetBase):
class Set(SequenceAndSetBase):
class Choice(Set):
class Any(OctetString):
    def __init__(self, value=noValue, **kwargs):
    def __and__(self, value):
    def __rand__(self, value):
    def __or__(self, value):
    def __ror__(self, value):
    def __xor__(self, value):
    def __rxor__(self, value):
    def __lshift__(self, value):
    def __rshift__(self, value):
    def __add__(self, value):
    def __radd__(self, value):
    def __sub__(self, value):
    def __rsub__(self, value):
    def __mul__(self, value):
    def __rmul__(self, value):
    def __mod__(self, value):
    def __rmod__(self, value):
    def __pow__(self, value, modulo=None):
    def __rpow__(self, value):
    def __floordiv__(self, value):
    def __rfloordiv__(self, value):
        def __div__(self, value):
        def __rdiv__(self, value):
        def __truediv__(self, value):
        def __rtruediv__(self, value):
        def __divmod__(self, value):
        def __rdivmod__(self, value):
    def __int__(self):
        def __long__(self):
    def __float__(self):
    def __abs__(self):
    def __index__(self):
    def __pos__(self):
    def __neg__(self):
    def __invert__(self):
    def __round__(self, n=0):
    def __floor__(self):
    def __ceil__(self):
    def __trunc__(self):
    def __lt__(self, value):
    def __le__(self, value):
    def __eq__(self, value):
    def __ne__(self, value):
    def __gt__(self, value):
    def __ge__(self, value):
    def prettyIn(self, value):
    def prettyOut(self, value):
    def getNamedValues(self):
    def setBitLength(self, bitLength):
    def __len__(self):
    def __init__(self, value=noValue, **kwargs):
    def __str__(self):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
    def __len__(self):
    def __getitem__(self, i):
    def __iter__(self):
    def __reversed__(self):
    def __add__(self, value):
    def __radd__(self, value):
    def __mul__(self, value):
    def __rmul__(self, value):
    def __lshift__(self, count):
    def __rshift__(self, count):
    def __int__(self):
    def __float__(self):
        def __long__(self):
    def asNumbers(self):
    def asOctets(self):
    def asInteger(self):
    def asBinary(self):
    def fromHexString(cls, value, internalFormat=False, prepend=None):
    def fromBinaryString(cls, value, internalFormat=False, prepend=None):
    def fromOctetString(cls, value, internalFormat=False, prepend=None, padding=0):
    def prettyIn(self, value):
    def __init__(self, value=noValue, **kwargs):
        def prettyIn(self, value):
        def __str__(self):
        def __unicode__(self):
        def asOctets(self):
        def asNumbers(self):
        def prettyIn(self, value):
        def __str__(self):
        def __bytes__(self):
        def asOctets(self):
        def asNumbers(self):
    def prettyOut(self, value):
    def prettyPrint(self, scope=0):
    def fromBinaryString(value):
    def fromHexString(value):
    def __len__(self):
    def __getitem__(self, i):
    def __iter__(self):
    def __contains__(self, value):
    def __add__(self, value):
    def __radd__(self, value):
    def __mul__(self, value):
    def __rmul__(self, value):
    def __int__(self):
    def __float__(self):
    def __reversed__(self):
    def prettyIn(self, value):
    def __add__(self, other):
    def __radd__(self, other):
    def asTuple(self):
    def __len__(self):
    def __getitem__(self, i):
    def __iter__(self):
    def __contains__(self, value):
    def index(self, suboid):
    def isPrefixOf(self, other):
    def prettyIn(self, value):
    def prettyOut(self, value):
    def __normalizeBase10(value):
    def prettyIn(self, value):
    def prettyPrint(self, scope=0):
    def isPlusInf(self):
    def isMinusInf(self):
    def isInf(self):
    def __add__(self, value):
    def __radd__(self, value):
    def __mul__(self, value):
    def __rmul__(self, value):
    def __sub__(self, value):
    def __rsub__(self, value):
    def __mod__(self, value):
    def __rmod__(self, value):
    def __pow__(self, value, modulo=None):
    def __rpow__(self, value):
        def __div__(self, value):
        def __rdiv__(self, value):
        def __truediv__(self, value):
        def __rtruediv__(self, value):
        def __divmod__(self, value):
        def __rdivmod__(self, value):
    def __int__(self):
        def __long__(self):
    def __float__(self):
    def __abs__(self):
    def __pos__(self):
    def __neg__(self):
    def __round__(self, n=0):
    def __floor__(self):
    def __ceil__(self):
    def __trunc__(self):
    def __lt__(self, value):
    def __le__(self, value):
    def __eq__(self, value):
    def __ne__(self, value):
    def __gt__(self, value):
    def __ge__(self, value):
        def __nonzero__(self):
        def __bool__(self):
    def __getitem__(self, idx):
    def isPlusInfinity(self):
    def isMinusInfinity(self):
    def isInfinity(self):
    def __init__(self, *args, **kwargs):
    def __getitem__(self, idx):
    def __setitem__(self, idx, value):
    def append(self, value):
    def count(self, value):
    def extend(self, values):
    def index(self, value, start=0, stop=None):
    def reverse(self):
    def sort(self, key=None, reverse=False):
    def __len__(self):
    def __iter__(self):
    def _cloneComponentValues(self, myClone, cloneValueFlag):
    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
    def setComponentByPosition(self, idx, value=noValue,
                               verifyConstraints=True,
                               matchTags=True,
                               matchConstraints=True):
    def componentTagMap(self):
    def components(self):
    def clear(self):
    def reset(self):
    def prettyPrint(self, scope=0):
    def prettyPrintType(self, scope=0):
    def isValue(self):
    def isInconsistent(self):
        def __init__(self):
        def __len__(self):
        def __contains__(self, item):
        def __iter__(self):
        def __getitem__(self, item):
        def getNameByPosition(self, idx):
        def getPositionByName(self, name):
        def addField(self, idx):
    def __init__(self, **kwargs):
    def __getitem__(self, idx):
    def __setitem__(self, idx, value):
    def __contains__(self, key):
    def __len__(self):
    def __iter__(self):
    def values(self):
    def keys(self):
    def items(self):
    def update(self, *iterValue, **mappingValue):
    def clear(self):
    def reset(self):
    def components(self):
    def _cloneComponentValues(self, myClone, cloneValueFlag):
    def getComponentByName(self, name, default=noValue, instantiate=True):
    def setComponentByName(self, name, value=noValue,
                           verifyConstraints=True,
                           matchTags=True,
                           matchConstraints=True):
    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
    def setComponentByPosition(self, idx, value=noValue,
                               verifyConstraints=True,
                               matchTags=True,
                               matchConstraints=True):
    def isValue(self):
    def isInconsistent(self):
    def prettyPrint(self, scope=0):
    def prettyPrintType(self, scope=0):
    def setDefaultComponents(self):
    def getComponentType(self):
    def getNameByPosition(self, idx):
    def getComponentTagMapNearPosition(self, idx):
    def getComponentPositionNearType(self, tagSet, idx):
    def getComponent(self, innerFlag=False):
    def getComponentByType(self, tagSet, default=noValue,
                           instantiate=True, innerFlag=False):
    def setComponentByType(self, tagSet, value=noValue,
                           verifyConstraints=True,
                           matchTags=True,
                           matchConstraints=True,
                           innerFlag=False):
    def componentTagMap(self):
    def __eq__(self, other):
    def __ne__(self, other):
    def __lt__(self, other):
    def __le__(self, other):
    def __gt__(self, other):
    def __ge__(self, other):
        def __nonzero__(self):
        def __bool__(self):
    def __len__(self):
    def __contains__(self, key):
    def __iter__(self):
    def values(self):
    def keys(self):
    def items(self):
    def checkConsistency(self):
    def _cloneComponentValues(self, myClone, cloneValueFlag):
    def getComponentByPosition(self, idx, default=noValue, instantiate=True):
    def setComponentByPosition(self, idx, value=noValue,
                               verifyConstraints=True,
                               matchTags=True,
                               matchConstraints=True):
    def effectiveTagSet(self):
    def tagMap(self):
    def getComponent(self, innerFlag=False):
    def getName(self, innerFlag=False):
    def isValue(self):
    def clear(self):
    def getMinTagSet(self):
    def tagMap(self): class ObjectDescriptor(char.GraphicString):
class TimeMixIn(object):
    class FixedOffset(datetime.tzinfo):
class GeneralizedTime(char.VisibleString, TimeMixIn):
class UTCTime(char.VisibleString, TimeMixIn):
        def __init__(self, offset=0, name='UTC'):
        def utcoffset(self, dt):
        def tzname(self, dt):
        def dst(self, dt):
    def asDateTime(self):
    def fromDateTime(cls, dt):
    UTC = FixedOffset()
import os
from pyasn1 import debug
from pyasn1 import error
from pyasn1.codec.ber import eoo
from pyasn1.codec.streaming import asSeekableStream
from pyasn1.codec.streaming import isEndOfStream
from pyasn1.codec.streaming import peekIntoStream
from pyasn1.codec.streaming import readFromStream
from pyasn1.compat.integer import from_bytes
from pyasn1.compat.octets import oct2int, octs2ints, ints2octs, null
from pyasn1.error import PyAsn1Error
from pyasn1.type import base
from pyasn1.type import char
from pyasn1.type import tag
from pyasn1.type import tagmap
from pyasn1.type import univ
from pyasn1.type import useful
                    asn1Object, chunk + substrate, length + len(chunk), options):
                yield chunk

            return

        if LOG:
            LOG('assembling constructed serialization')

        # All inner fragments are of the same type, treat them as octet string
        substrateFun = self.substrateCollector

        while True:  # loop over fragments

            for component in decodeFun(
                    substrate, asn1Spec, substrateFun=substrateFun,
                    allowEoo=True, **options):

                if isinstance(component, SubstrateUnderrunError):
                    yield component

                if component is eoo.endOfOctets:
                    break

            if component is eoo.endOfOctets:
                break

            chunk += component

        if substrateFun:
            yield chunk  # TODO: Weird

        else:
            yield self._createComponent(asn1Spec, tagSet, chunk, **options)


# character string types
class UTF8StringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.UTF8String()


class NumericStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.NumericString()


class PrintableStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.PrintableString()


class TeletexStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.TeletexString()


class VideotexStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.VideotexString()


class IA5StringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.IA5String()


class GraphicStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.GraphicString()


class VisibleStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.VisibleString()


class GeneralStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.GeneralString()


class UniversalStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.UniversalString()


class BMPStringPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = char.BMPString()


# "useful" types
class ObjectDescriptorPayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = useful.ObjectDescriptor()


class GeneralizedTimePayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = useful.GeneralizedTime()


class UTCTimePayloadDecoder(OctetStringPayloadDecoder):
    protoComponent = useful.UTCTime()


TAG_MAP = {
    univ.Integer.tagSet: IntegerPayloadDecoder(),
    univ.Boolean.tagSet: BooleanPayloadDecoder(),
    univ.BitString.tagSet: BitStringPayloadDecoder(),
    univ.OctetString.tagSet: OctetStringPayloadDecoder(),
    univ.Null.tagSet: NullPayloadDecoder(),
    univ.ObjectIdentifier.tagSet: ObjectIdentifierPayloadDecoder(),
    univ.Enumerated.tagSet: IntegerPayloadDecoder(),
    univ.Real.tagSet: RealPayloadDecoder(),
    univ.Sequence.tagSet: SequenceOrSequenceOfPayloadDecoder(),  # conflicts with SequenceOf
    univ.Set.tagSet: SetOrSetOfPayloadDecoder(),  # conflicts with SetOf
    univ.Choice.tagSet: ChoicePayloadDecoder(),  # conflicts with Any
    # character string types
    char.UTF8String.tagSet: UTF8StringPayloadDecoder(),
    char.NumericString.tagSet: NumericStringPayloadDecoder(),
    char.PrintableString.tagSet: PrintableStringPayloadDecoder(),
    char.TeletexString.tagSet: TeletexStringPayloadDecoder(),
    char.VideotexString.tagSet: VideotexStringPayloadDecoder(),
    char.IA5String.tagSet: IA5StringPayloadDecoder(),
    char.GraphicString.tagSet: GraphicStringPayloadDecoder(),
    char.VisibleString.tagSet: VisibleStringPayloadDecoder(),
    char.GeneralString.tagSet: GeneralStringPayloadDecoder(),
    char.UniversalString.tagSet: UniversalStringPayloadDecoder(),
    char.BMPString.tagSet: BMPStringPayloadDecoder(),
    # useful types
    useful.ObjectDescriptor.tagSet: ObjectDescriptorPayloadDecoder(),
    useful.GeneralizedTime.tagSet: GeneralizedTimePayloadDecoder(),

    useful.UTCTime.tagSet: UTCTimePayloadDecoder()