#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
# Generated Tue Feb 13 19:16:45 2018 by generateDS.py version 2.29.5.
# Python 2.7.13 (default, Nov 24 2017, 17:33:09)  [GCC 6.3.0 20170516]
#
# Command line options:
#   ('-f', '')
#   ('-o', 'compound.py')
#   ('-s', 'compoundsuper.py')
#   ('--super', 'compoundsuper')
#
# Command line arguments:
#   /home/axel/src/picongpu/docs/xml/compound.xsd
#
# Command line:
#   /home/axel/.local/bin/generateDS.py -f -o "compound.py" -s "compoundsuper.py" --super="compoundsuper" /home/axel/src/picongpu/docs/xml/compound.xsd
#
# Current working directory (os.getcwd()):
#   parser
#

import sys
import re as re_
import base64
import datetime as datetime_
import warnings as warnings_
try:
    from lxml import etree as etree_
except ImportError:
    from xml.etree import ElementTree as etree_


Validate_simpletypes_ = True
if sys.version_info.major == 2:
    BaseStrType_ = basestring
else:
    BaseStrType_ = str


def parsexml_(infile, parser=None, **kwargs):
    if parser is None:
        # Use the lxml ElementTree compatible parser so that, e.g.,
        #   we ignore comments.
        try:
            parser = etree_.ETCompatXMLParser()
        except AttributeError:
            # fallback to xml.etree
            parser = etree_.XMLParser()
    doc = etree_.parse(infile, parser=parser, **kwargs)
    return doc

def parsexmlstring_(instring, parser=None, **kwargs):
    if parser is None:
        # Use the lxml ElementTree compatible parser so that, e.g.,
        #   we ignore comments.
        try:
            parser = etree_.ETCompatXMLParser()
        except AttributeError:
            # fallback to xml.etree
            parser = etree_.XMLParser()
    element = etree_.fromstring(instring, parser=parser, **kwargs)
    return element

#
# Namespace prefix definition table (and other attributes, too)
#
# The module generatedsnamespaces, if it is importable, must contain
# a dictionary named GeneratedsNamespaceDefs.  This Python dictionary
# should map element type names (strings) to XML schema namespace prefix
# definitions.  The export method for any class for which there is
# a namespace prefix definition, will export that definition in the
# XML representation of that element.  See the export method of
# any generated element type class for a example of the use of this
# table.
# A sample table is:
#
#     # File: generatedsnamespaces.py
#
#     GenerateDSNamespaceDefs = {
#         "ElementtypeA": "http://www.xxx.com/namespaceA",
#         "ElementtypeB": "http://www.xxx.com/namespaceB",
#     }
#

try:
    from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_
except ImportError:
    GenerateDSNamespaceDefs_ = {}

#
# The root super-class for element type classes
#
# Calls to the methods in these classes are generated by generateDS.py.
# You can replace these methods by re-implementing the following class
#   in a module named generatedssuper.py.

try:
    from generatedssuper import GeneratedsSuper
except ImportError as exp:
    
    class GeneratedsSuper(object):
        tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$')
        class _FixedOffsetTZ(datetime_.tzinfo):
            def __init__(self, offset, name):
                self.__offset = datetime_.timedelta(minutes=offset)
                self.__name = name
            def utcoffset(self, dt):
                return self.__offset
            def tzname(self, dt):
                return self.__name
            def dst(self, dt):
                return None
        def gds_format_string(self, input_data, input_name=''):
            return input_data
        def gds_validate_string(self, input_data, node=None, input_name=''):
            if not input_data:
                return ''
            else:
                return input_data
        def gds_format_base64(self, input_data, input_name=''):
            return base64.b64encode(input_data)
        def gds_validate_base64(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_integer(self, input_data, input_name=''):
            return '%d' % input_data
        def gds_validate_integer(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_integer_list(self, input_data, input_name=''):
            return '%s' % ' '.join(input_data)
        def gds_validate_integer_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    int(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of integers')
            return values
        def gds_format_float(self, input_data, input_name=''):
            return ('%.15f' % input_data).rstrip('0')
        def gds_validate_float(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_float_list(self, input_data, input_name=''):
            return '%s' % ' '.join(input_data)
        def gds_validate_float_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    float(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of floats')
            return values
        def gds_format_double(self, input_data, input_name=''):
            return '%e' % input_data
        def gds_validate_double(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_double_list(self, input_data, input_name=''):
            return '%s' % ' '.join(input_data)
        def gds_validate_double_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    float(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of doubles')
            return values
        def gds_format_boolean(self, input_data, input_name=''):
            return ('%s' % input_data).lower()
        def gds_validate_boolean(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_boolean_list(self, input_data, input_name=''):
            return '%s' % ' '.join(input_data)
        def gds_validate_boolean_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                if value not in ('true', '1', 'false', '0', ):
                    raise_parse_error(
                        node,
                        'Requires sequence of booleans '
                        '("true", "1", "false", "0")')
            return values
        def gds_validate_datetime(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_datetime(self, input_data, input_name=''):
            if input_data.microsecond == 0:
                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % (
                    input_data.year,
                    input_data.month,
                    input_data.day,
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                )
            else:
                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % (
                    input_data.year,
                    input_data.month,
                    input_data.day,
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
                )
            if input_data.tzinfo is not None:
                tzoff = input_data.tzinfo.utcoffset(input_data)
                if tzoff is not None:
                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
                    if total_seconds == 0:
                        _svalue += 'Z'
                    else:
                        if total_seconds < 0:
                            _svalue += '-'
                            total_seconds *= -1
                        else:
                            _svalue += '+'
                        hours = total_seconds // 3600
                        minutes = (total_seconds - (hours * 3600)) // 60
                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
            return _svalue
        @classmethod
        def gds_parse_datetime(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            time_parts = input_data.split('.')
            if len(time_parts) > 1:
                micro_seconds = int(float('0.' + time_parts[1]) * 1000000)
                input_data = '%s.%s' % (time_parts[0], micro_seconds, )
                dt = datetime_.datetime.strptime(
                    input_data, '%Y-%m-%dT%H:%M:%S.%f')
            else:
                dt = datetime_.datetime.strptime(
                    input_data, '%Y-%m-%dT%H:%M:%S')
            dt = dt.replace(tzinfo=tz)
            return dt
        def gds_validate_date(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_date(self, input_data, input_name=''):
            _svalue = '%04d-%02d-%02d' % (
                input_data.year,
                input_data.month,
                input_data.day,
            )
            try:
                if input_data.tzinfo is not None:
                    tzoff = input_data.tzinfo.utcoffset(input_data)
                    if tzoff is not None:
                        total_seconds = tzoff.seconds + (86400 * tzoff.days)
                        if total_seconds == 0:
                            _svalue += 'Z'
                        else:
                            if total_seconds < 0:
                                _svalue += '-'
                                total_seconds *= -1
                            else:
                                _svalue += '+'
                            hours = total_seconds // 3600
                            minutes = (total_seconds - (hours * 3600)) // 60
                            _svalue += '{0:02d}:{1:02d}'.format(
                                hours, minutes)
            except AttributeError:
                pass
            return _svalue
        @classmethod
        def gds_parse_date(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d')
            dt = dt.replace(tzinfo=tz)
            return dt.date()
        def gds_validate_time(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_time(self, input_data, input_name=''):
            if input_data.microsecond == 0:
                _svalue = '%02d:%02d:%02d' % (
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                )
            else:
                _svalue = '%02d:%02d:%02d.%s' % (
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
                )
            if input_data.tzinfo is not None:
                tzoff = input_data.tzinfo.utcoffset(input_data)
                if tzoff is not None:
                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
                    if total_seconds == 0:
                        _svalue += 'Z'
                    else:
                        if total_seconds < 0:
                            _svalue += '-'
                            total_seconds *= -1
                        else:
                            _svalue += '+'
                        hours = total_seconds // 3600
                        minutes = (total_seconds - (hours * 3600)) // 60
                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
            return _svalue
        def gds_validate_simple_patterns(self, patterns, target):
            # pat is a list of lists of strings/patterns.  We should:
            # - AND the outer elements
            # - OR the inner elements
            found1 = True
            for patterns1 in patterns:
                found2 = False
                for patterns2 in patterns1:
                    if re_.search(patterns2, target) is not None:
                        found2 = True
                        break
                if not found2:
                    found1 = False
                    break
            return found1
        @classmethod
        def gds_parse_time(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            if len(input_data.split('.')) > 1:
                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f')
            else:
                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S')
            dt = dt.replace(tzinfo=tz)
            return dt.time()
        def gds_str_lower(self, instring):
            return instring.lower()
        def get_path_(self, node):
            path_list = []
            self.get_path_list_(node, path_list)
            path_list.reverse()
            path = '/'.join(path_list)
            return path
        Tag_strip_pattern_ = re_.compile(r'\{.*\}')
        def get_path_list_(self, node, path_list):
            if node is None:
                return
            tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag)
            if tag:
                path_list.append(tag)
            self.get_path_list_(node.getparent(), path_list)
        def get_class_obj_(self, node, default_class=None):
            class_obj1 = default_class
            if 'xsi' in node.nsmap:
                classname = node.get('{%s}type' % node.nsmap['xsi'])
                if classname is not None:
                    names = classname.split(':')
                    if len(names) == 2:
                        classname = names[1]
                    class_obj2 = globals().get(classname)
                    if class_obj2 is not None:
                        class_obj1 = class_obj2
            return class_obj1
        def gds_build_any(self, node, type_name=None):
            return None
        @classmethod
        def gds_reverse_node_mapping(cls, mapping):
            return dict(((v, k) for k, v in mapping.iteritems()))
        @staticmethod
        def gds_encode(instring):
            if sys.version_info.major == 2:
                return instring.encode(ExternalEncoding)
            else:
                return instring
        @staticmethod
        def convert_unicode(instring):
            if isinstance(instring, str):
                result = quote_xml(instring)
            elif sys.version_info.major == 2 and isinstance(instring, unicode):
                result = quote_xml(instring).encode('utf8')
            else:
                result = GeneratedsSuper.gds_encode(str(instring))
            return result
        def __eq__(self, other):
            if type(self) != type(other):
                return False
            return self.__dict__ == other.__dict__
        def __ne__(self, other):
            return not self.__eq__(other)
    
    def getSubclassFromModule_(module, class_):
        '''Get the subclass of a class from a specific module.'''
        name = class_.__name__ + 'Sub'
        if hasattr(module, name):
            return getattr(module, name)
        else:
            return None


#
# If you have installed IPython you can uncomment and use the following.
# IPython is available from http://ipython.scipy.org/.
#

## from IPython.Shell import IPShellEmbed
## args = ''
## ipshell = IPShellEmbed(args,
##     banner = 'Dropping into IPython',
##     exit_msg = 'Leaving Interpreter, back to program.')

# Then use the following line where and when you want to drop into the
# IPython shell:
#    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')

#
# Globals
#

ExternalEncoding = 'ascii'
Tag_pattern_ = re_.compile(r'({.*})?(.*)')
String_cleanup_pat_ = re_.compile(r"[\n\r\s]+")
Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)')
CDATA_pattern_ = re_.compile(r"<!\[CDATA\[.*?\]\]>", re_.DOTALL)

# Change this to redirect the generated superclass module to use a
# specific subclass module.
CurrentSubclassModule_ = None

#
# Support/utility functions.
#


def showIndent(outfile, level, pretty_print=True):
    if pretty_print:
        for idx in range(level):
            outfile.write('    ')


def quote_xml(inStr):
    "Escape markup chars, but do not modify CDATA sections."
    if not inStr:
        return ''
    s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr)
    s2 = ''
    pos = 0
    matchobjects = CDATA_pattern_.finditer(s1)
    for mo in matchobjects:
        s3 = s1[pos:mo.start()]
        s2 += quote_xml_aux(s3)
        s2 += s1[mo.start():mo.end()]
        pos = mo.end()
    s3 = s1[pos:]
    s2 += quote_xml_aux(s3)
    return s2


def quote_xml_aux(inStr):
    s1 = inStr.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    return s1


def quote_attrib(inStr):
    s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr)
    s1 = s1.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    if '"' in s1:
        if "'" in s1:
            s1 = '"%s"' % s1.replace('"', "&quot;")
        else:
            s1 = "'%s'" % s1
    else:
        s1 = '"%s"' % s1
    return s1


def quote_python(inStr):
    s1 = inStr
    if s1.find("'") == -1:
        if s1.find('\n') == -1:
            return "'%s'" % s1
        else:
            return "'''%s'''" % s1
    else:
        if s1.find('"') != -1:
            s1 = s1.replace('"', '\\"')
        if s1.find('\n') == -1:
            return '"%s"' % s1
        else:
            return '"""%s"""' % s1


def get_all_text_(node):
    if node.text is not None:
        text = node.text
    else:
        text = ''
    for child in node:
        if child.tail is not None:
            text += child.tail
    return text


def find_attr_value_(attr_name, node):
    attrs = node.attrib
    attr_parts = attr_name.split(':')
    value = None
    if len(attr_parts) == 1:
        value = attrs.get(attr_name)
    elif len(attr_parts) == 2:
        prefix, name = attr_parts
        namespace = node.nsmap.get(prefix)
        if namespace is not None:
            value = attrs.get('{%s}%s' % (namespace, name, ))
    return value


class GDSParseError(Exception):
    pass


def raise_parse_error(node, msg):
    msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, )
    raise GDSParseError(msg)


class MixedContainer:

    node_type = "mixedcontainer"

    # Constants for category:
    CategoryNone = 0
    CategoryText = 1
    CategorySimple = 2
    CategoryComplex = 3
    # Constants for content_type:
    TypeNone = 0
    TypeText = 1
    TypeString = 2
    TypeInteger = 3
    TypeFloat = 4
    TypeDecimal = 5
    TypeDouble = 6
    TypeBoolean = 7
    TypeBase64 = 8
    def __init__(self, category, content_type, name, value):
        self.category = category
        self.content_type = content_type
        self.name = name
        self.value = value
    def getCategory(self):
        return self.category
    def getContenttype(self, content_type):
        return self.content_type
    def getValue(self):
        return self.value
    def getName(self):
        return self.name
    def export(self, outfile, level, name, namespace,
               pretty_print=True):
        if self.category == MixedContainer.CategoryText:
            # Prevent exporting empty content as empty lines.
            if self.value.strip():
                outfile.write(self.value)
        elif self.category == MixedContainer.CategorySimple:
            self.exportSimple(outfile, level, name)
        else:    # category == MixedContainer.CategoryComplex
            self.value.export(
                outfile, level, namespace, name,
                pretty_print=pretty_print)
    def exportSimple(self, outfile, level, name):
        if self.content_type == MixedContainer.TypeString:
            outfile.write('<%s>%s</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeInteger or \
                self.content_type == MixedContainer.TypeBoolean:
            outfile.write('<%s>%d</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeFloat or \
                self.content_type == MixedContainer.TypeDecimal:
            outfile.write('<%s>%f</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeDouble:
            outfile.write('<%s>%g</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeBase64:
            outfile.write('<%s>%s</%s>' % (
                self.name,
                base64.b64encode(self.value),
                self.name))
    def to_etree(self, element):
        if self.category == MixedContainer.CategoryText:
            # Prevent exporting empty content as empty lines.
            if self.value.strip():
                if len(element) > 0:
                    if element[-1].tail is None:
                        element[-1].tail = self.value
                    else:
                        element[-1].tail += self.value
                else:
                    if element.text is None:
                        element.text = self.value
                    else:
                        element.text += self.value
        elif self.category == MixedContainer.CategorySimple:
            subelement = etree_.SubElement(
                element, '%s' % self.name)
            subelement.text = self.to_etree_simple()
        else:    # category == MixedContainer.CategoryComplex
            self.value.to_etree(element)
    def to_etree_simple(self):
        if self.content_type == MixedContainer.TypeString:
            text = self.value
        elif (self.content_type == MixedContainer.TypeInteger or
                self.content_type == MixedContainer.TypeBoolean):
            text = '%d' % self.value
        elif (self.content_type == MixedContainer.TypeFloat or
                self.content_type == MixedContainer.TypeDecimal):
            text = '%f' % self.value
        elif self.content_type == MixedContainer.TypeDouble:
            text = '%g' % self.value
        elif self.content_type == MixedContainer.TypeBase64:
            text = '%s' % base64.b64encode(self.value)
        return text
    def exportLiteral(self, outfile, level, name):
        if self.category == MixedContainer.CategoryText:
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
                    self.category, self.content_type,
                    self.name, self.value))
        elif self.category == MixedContainer.CategorySimple:
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
                    self.category, self.content_type,
                    self.name, self.value))
        else:    # category == MixedContainer.CategoryComplex
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s",\n' % (
                    self.category, self.content_type, self.name,))
            self.value.exportLiteral(outfile, level + 1)
            showIndent(outfile, level)
            outfile.write(')\n')


class MemberSpec_(object):
    def __init__(self, name='', data_type='', container=0,
            optional=0, child_attrs=None, choice=None):
        self.name = name
        self.data_type = data_type
        self.container = container
        self.child_attrs = child_attrs
        self.choice = choice
        self.optional = optional
    def set_name(self, name): self.name = name
    def get_name(self): return self.name
    def set_data_type(self, data_type): self.data_type = data_type
    def get_data_type_chain(self): return self.data_type
    def get_data_type(self):
        if isinstance(self.data_type, list):
            if len(self.data_type) > 0:
                return self.data_type[-1]
            else:
                return 'xs:string'
        else:
            return self.data_type
    def set_container(self, container): self.container = container
    def get_container(self): return self.container
    def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs
    def get_child_attrs(self): return self.child_attrs
    def set_choice(self, choice): self.choice = choice
    def get_choice(self): return self.choice
    def set_optional(self, optional): self.optional = optional
    def get_optional(self): return self.optional


def _cast(typ, value):
    if typ is None or value is None:
        return value
    return typ(value)

#
# Data representation classes.
#


class DoxygenType(GeneratedsSuper):
    node_type = "doxygendef"

    subclass = None
    superclass = None
    def __init__(self, version=None, compounddef=None):
        self.original_tagname_ = None
        self.version = _cast(None, version)
        if compounddef is None:
            self.compounddef = []
        else:
            self.compounddef = compounddef
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, DoxygenType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if DoxygenType.subclass:
            return DoxygenType.subclass(*args_, **kwargs_)
        else:
            return DoxygenType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_compounddef(self): return self.compounddef
    def set_compounddef(self, compounddef): self.compounddef = compounddef
    def add_compounddef(self, value): self.compounddef.append(value)
    def insert_compounddef_at(self, index, value): self.compounddef.insert(index, value)
    def replace_compounddef_at(self, index, value): self.compounddef[index] = value
    def get_version(self): return self.version
    def set_version(self, version): self.version = version
    def validate_DoxVersionNumber(self, value):
        # Validate type DoxVersionNumber, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            if not self.gds_validate_simple_patterns(
                    self.validate_DoxVersionNumber_patterns_, value):
                warnings_.warn('Value "%s" does not match xsd pattern restrictions: %s' % (value.encode('utf-8'), self.validate_DoxVersionNumber_patterns_, ))
    validate_DoxVersionNumber_patterns_ = [['^\\d+\\.\\d+.*$']]
    def hasContent_(self):
        if (
            self.compounddef
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='DoxygenType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('DoxygenType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='DoxygenType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='DoxygenType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='DoxygenType'):
        if self.version is not None and 'version' not in already_processed:
            already_processed.add('version')
            outfile.write(' version=%s' % (quote_attrib(self.version), ))
    def exportChildren(self, outfile, level, namespace_='', name_='DoxygenType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for compounddef_ in self.compounddef:
            compounddef_.export(outfile, level, namespace_, name_='compounddef', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('version', node)
        if value is not None and 'version' not in already_processed:
            already_processed.add('version')
            self.version = value
            self.validate_DoxVersionNumber(self.version)    # validate type DoxVersionNumber
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'compounddef':
            obj_ = compounddefType.factory()
            obj_.build(child_)
            self.compounddef.append(obj_)
            obj_.original_tagname_ = 'compounddef'
# end class DoxygenType


class compounddefType(GeneratedsSuper):
    node_type = "compounddef"

    subclass = None
    superclass = None
    def __init__(self, id=None, kind=None, language=None, prot=None, final=None, sealed=None, abstract=None, compoundname=None, title=None, basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.kind = _cast(None, kind)
        self.language = _cast(None, language)
        self.prot = _cast(None, prot)
        self.final = _cast(None, final)
        self.sealed = _cast(None, sealed)
        self.abstract = _cast(None, abstract)
        self.compoundname = compoundname
        self.title = title
        if basecompoundref is None:
            self.basecompoundref = []
        else:
            self.basecompoundref = basecompoundref
        if derivedcompoundref is None:
            self.derivedcompoundref = []
        else:
            self.derivedcompoundref = derivedcompoundref
        if includes is None:
            self.includes = []
        else:
            self.includes = includes
        if includedby is None:
            self.includedby = []
        else:
            self.includedby = includedby
        self.incdepgraph = incdepgraph
        self.invincdepgraph = invincdepgraph
        if innerdir is None:
            self.innerdir = []
        else:
            self.innerdir = innerdir
        if innerfile is None:
            self.innerfile = []
        else:
            self.innerfile = innerfile
        if innerclass is None:
            self.innerclass = []
        else:
            self.innerclass = innerclass
        if innernamespace is None:
            self.innernamespace = []
        else:
            self.innernamespace = innernamespace
        if innerpage is None:
            self.innerpage = []
        else:
            self.innerpage = innerpage
        if innergroup is None:
            self.innergroup = []
        else:
            self.innergroup = innergroup
        self.templateparamlist = templateparamlist
        if sectiondef is None:
            self.sectiondef = []
        else:
            self.sectiondef = sectiondef
        self.briefdescription = briefdescription
        self.detaileddescription = detaileddescription
        self.inheritancegraph = inheritancegraph
        self.collaborationgraph = collaborationgraph
        self.programlisting = programlisting
        self.location = location
        self.listofallmembers = listofallmembers
        self.namespaces = []
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, compounddefType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if compounddefType.subclass:
            return compounddefType.subclass(*args_, **kwargs_)
        else:
            return compounddefType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_compoundname(self): return self.compoundname
    def set_compoundname(self, compoundname): self.compoundname = compoundname
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_basecompoundref(self): return self.basecompoundref
    def set_basecompoundref(self, basecompoundref): self.basecompoundref = basecompoundref
    def add_basecompoundref(self, value): self.basecompoundref.append(value)
    def insert_basecompoundref_at(self, index, value): self.basecompoundref.insert(index, value)
    def replace_basecompoundref_at(self, index, value): self.basecompoundref[index] = value
    def get_derivedcompoundref(self): return self.derivedcompoundref
    def set_derivedcompoundref(self, derivedcompoundref): self.derivedcompoundref = derivedcompoundref
    def add_derivedcompoundref(self, value): self.derivedcompoundref.append(value)
    def insert_derivedcompoundref_at(self, index, value): self.derivedcompoundref.insert(index, value)
    def replace_derivedcompoundref_at(self, index, value): self.derivedcompoundref[index] = value
    def get_includes(self): return self.includes
    def set_includes(self, includes): self.includes = includes
    def add_includes(self, value): self.includes.append(value)
    def insert_includes_at(self, index, value): self.includes.insert(index, value)
    def replace_includes_at(self, index, value): self.includes[index] = value
    def get_includedby(self): return self.includedby
    def set_includedby(self, includedby): self.includedby = includedby
    def add_includedby(self, value): self.includedby.append(value)
    def insert_includedby_at(self, index, value): self.includedby.insert(index, value)
    def replace_includedby_at(self, index, value): self.includedby[index] = value
    def get_incdepgraph(self): return self.incdepgraph
    def set_incdepgraph(self, incdepgraph): self.incdepgraph = incdepgraph
    def get_invincdepgraph(self): return self.invincdepgraph
    def set_invincdepgraph(self, invincdepgraph): self.invincdepgraph = invincdepgraph
    def get_innerdir(self): return self.innerdir
    def set_innerdir(self, innerdir): self.innerdir = innerdir
    def add_innerdir(self, value): self.innerdir.append(value)
    def insert_innerdir_at(self, index, value): self.innerdir.insert(index, value)
    def replace_innerdir_at(self, index, value): self.innerdir[index] = value
    def get_innerfile(self): return self.innerfile
    def set_innerfile(self, innerfile): self.innerfile = innerfile
    def add_innerfile(self, value): self.innerfile.append(value)
    def insert_innerfile_at(self, index, value): self.innerfile.insert(index, value)
    def replace_innerfile_at(self, index, value): self.innerfile[index] = value
    def get_innerclass(self): return self.innerclass
    def set_innerclass(self, innerclass): self.innerclass = innerclass
    def add_innerclass(self, value): self.innerclass.append(value)
    def insert_innerclass_at(self, index, value): self.innerclass.insert(index, value)
    def replace_innerclass_at(self, index, value): self.innerclass[index] = value
    def get_innernamespace(self): return self.innernamespace
    def set_innernamespace(self, innernamespace): self.innernamespace = innernamespace
    def add_innernamespace(self, value): self.innernamespace.append(value)
    def insert_innernamespace_at(self, index, value): self.innernamespace.insert(index, value)
    def replace_innernamespace_at(self, index, value): self.innernamespace[index] = value
    def get_innerpage(self): return self.innerpage
    def set_innerpage(self, innerpage): self.innerpage = innerpage
    def add_innerpage(self, value): self.innerpage.append(value)
    def insert_innerpage_at(self, index, value): self.innerpage.insert(index, value)
    def replace_innerpage_at(self, index, value): self.innerpage[index] = value
    def get_innergroup(self): return self.innergroup
    def set_innergroup(self, innergroup): self.innergroup = innergroup
    def add_innergroup(self, value): self.innergroup.append(value)
    def insert_innergroup_at(self, index, value): self.innergroup.insert(index, value)
    def replace_innergroup_at(self, index, value): self.innergroup[index] = value
    def get_templateparamlist(self): return self.templateparamlist
    def set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist
    def get_sectiondef(self): return self.sectiondef
    def set_sectiondef(self, sectiondef): self.sectiondef = sectiondef
    def add_sectiondef(self, value): self.sectiondef.append(value)
    def insert_sectiondef_at(self, index, value): self.sectiondef.insert(index, value)
    def replace_sectiondef_at(self, index, value): self.sectiondef[index] = value
    def get_briefdescription(self): return self.briefdescription
    def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
    def get_detaileddescription(self): return self.detaileddescription
    def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
    def get_inheritancegraph(self): return self.inheritancegraph
    def set_inheritancegraph(self, inheritancegraph): self.inheritancegraph = inheritancegraph
    def get_collaborationgraph(self): return self.collaborationgraph
    def set_collaborationgraph(self, collaborationgraph): self.collaborationgraph = collaborationgraph
    def get_programlisting(self): return self.programlisting
    def set_programlisting(self, programlisting): self.programlisting = programlisting
    def get_location(self): return self.location
    def set_location(self, location): self.location = location
    def get_listofallmembers(self): return self.listofallmembers
    def set_listofallmembers(self, listofallmembers): self.listofallmembers = listofallmembers
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def get_language(self): return self.language
    def set_language(self, language): self.language = language
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_final(self): return self.final
    def set_final(self, final): self.final = final
    def get_sealed(self): return self.sealed
    def set_sealed(self, sealed): self.sealed = sealed
    def get_abstract(self): return self.abstract
    def set_abstract(self, abstract): self.abstract = abstract
    def validate_DoxCompoundKind(self, value):
        # Validate type DoxCompoundKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['class', 'struct', 'union', 'interface', 'protocol', 'category', 'exception', 'service', 'singleton', 'module', 'type', 'file', 'namespace', 'group', 'page', 'example', 'dir']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxCompoundKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxLanguage(self, value):
        # Validate type DoxLanguage, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['Unknown', 'IDL', 'Java', 'C#', 'D', 'PHP', 'Objective-C', 'C++', 'Javascript', 'Python', 'Fortran', 'VHDL', 'XML', 'SQL', 'Tcl', 'Markdown']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxLanguage' % {"value" : value.encode("utf-8")} )
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxBool(self, value):
        # Validate type DoxBool, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['yes', 'no']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxBool' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.compoundname is not None or
            self.title is not None or
            self.basecompoundref or
            self.derivedcompoundref or
            self.includes or
            self.includedby or
            self.incdepgraph is not None or
            self.invincdepgraph is not None or
            self.innerdir or
            self.innerfile or
            self.innerclass or
            self.innernamespace or
            self.innerpage or
            self.innergroup or
            self.templateparamlist is not None or
            self.sectiondef or
            self.briefdescription is not None or
            self.detaileddescription is not None or
            self.inheritancegraph is not None or
            self.collaborationgraph is not None or
            self.programlisting is not None or
            self.location is not None or
            self.listofallmembers is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='compounddefType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('compounddefType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='compounddefType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='compounddefType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='compounddefType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
        if self.kind is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
        if self.language is not None and 'language' not in already_processed:
            already_processed.add('language')
            outfile.write(' language=%s' % (quote_attrib(self.language), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
        if self.final is not None and 'final' not in already_processed:
            already_processed.add('final')
            outfile.write(' final=%s' % (quote_attrib(self.final), ))
        if self.sealed is not None and 'sealed' not in already_processed:
            already_processed.add('sealed')
            outfile.write(' sealed=%s' % (quote_attrib(self.sealed), ))
        if self.abstract is not None and 'abstract' not in already_processed:
            already_processed.add('abstract')
            outfile.write(' abstract=%s' % (quote_attrib(self.abstract), ))
    def exportChildren(self, outfile, level, namespace_='', name_='compounddefType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.compoundname is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<compoundname>%s</compoundname>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.compoundname), input_name='compoundname')), eol_))
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for basecompoundref_ in self.basecompoundref:
            basecompoundref_.export(outfile, level, namespace_, name_='basecompoundref', pretty_print=pretty_print)
        for derivedcompoundref_ in self.derivedcompoundref:
            derivedcompoundref_.export(outfile, level, namespace_, name_='derivedcompoundref', pretty_print=pretty_print)
        for includes_ in self.includes:
            includes_.export(outfile, level, namespace_, name_='includes', pretty_print=pretty_print)
        for includedby_ in self.includedby:
            includedby_.export(outfile, level, namespace_, name_='includedby', pretty_print=pretty_print)
        if self.incdepgraph is not None:
            self.incdepgraph.export(outfile, level, namespace_, name_='incdepgraph', pretty_print=pretty_print)
        if self.invincdepgraph is not None:
            self.invincdepgraph.export(outfile, level, namespace_, name_='invincdepgraph', pretty_print=pretty_print)
        for innerdir_ in self.innerdir:
            innerdir_.export(outfile, level, namespace_, name_='innerdir', pretty_print=pretty_print)
        for innerfile_ in self.innerfile:
            innerfile_.export(outfile, level, namespace_, name_='innerfile', pretty_print=pretty_print)
        for innerclass_ in self.innerclass:
            innerclass_.export(outfile, level, namespace_, name_='innerclass', pretty_print=pretty_print)
        for innernamespace_ in self.innernamespace:
            innernamespace_.export(outfile, level, namespace_, name_='innernamespace', pretty_print=pretty_print)
        for innerpage_ in self.innerpage:
            innerpage_.export(outfile, level, namespace_, name_='innerpage', pretty_print=pretty_print)
        for innergroup_ in self.innergroup:
            innergroup_.export(outfile, level, namespace_, name_='innergroup', pretty_print=pretty_print)
        if self.templateparamlist is not None:
            self.templateparamlist.export(outfile, level, namespace_, name_='templateparamlist', pretty_print=pretty_print)
        for sectiondef_ in self.sectiondef:
            sectiondef_.export(outfile, level, namespace_, name_='sectiondef', pretty_print=pretty_print)
        if self.briefdescription is not None:
            self.briefdescription.export(outfile, level, namespace_, name_='briefdescription', pretty_print=pretty_print)
        if self.detaileddescription is not None:
            self.detaileddescription.export(outfile, level, namespace_, name_='detaileddescription', pretty_print=pretty_print)
        if self.inheritancegraph is not None:
            self.inheritancegraph.export(outfile, level, namespace_, name_='inheritancegraph', pretty_print=pretty_print)
        if self.collaborationgraph is not None:
            self.collaborationgraph.export(outfile, level, namespace_, name_='collaborationgraph', pretty_print=pretty_print)
        if self.programlisting is not None:
            self.programlisting.export(outfile, level, namespace_, name_='programlisting', pretty_print=pretty_print)
        if self.location is not None:
            self.location.export(outfile, level, namespace_, name_='location', pretty_print=pretty_print)
        if self.listofallmembers is not None:
            self.listofallmembers.export(outfile, level, namespace_, name_='listofallmembers', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
        value = find_attr_value_('kind', node)
        if value is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            self.kind = value
            self.validate_DoxCompoundKind(self.kind)    # validate type DoxCompoundKind
        value = find_attr_value_('language', node)
        if value is not None and 'language' not in already_processed:
            already_processed.add('language')
            self.language = value
            self.validate_DoxLanguage(self.language)    # validate type DoxLanguage
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
        value = find_attr_value_('final', node)
        if value is not None and 'final' not in already_processed:
            already_processed.add('final')
            self.final = value
            self.validate_DoxBool(self.final)    # validate type DoxBool
        value = find_attr_value_('sealed', node)
        if value is not None and 'sealed' not in already_processed:
            already_processed.add('sealed')
            self.sealed = value
            self.validate_DoxBool(self.sealed)    # validate type DoxBool
        value = find_attr_value_('abstract', node)
        if value is not None and 'abstract' not in already_processed:
            already_processed.add('abstract')
            self.abstract = value
            self.validate_DoxBool(self.abstract)    # validate type DoxBool
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'compoundname':
            compoundname_ = child_.text
            compoundname_ = self.gds_validate_string(compoundname_, node, 'compoundname')
            self.compoundname = compoundname_
        elif nodeName_ == 'title':
            title_ = child_.text
            title_ = self.gds_validate_string(title_, node, 'title')
            self.title = title_
        elif nodeName_ == 'basecompoundref':
            obj_ = compoundRefType.factory()
            obj_.build(child_)
            self.basecompoundref.append(obj_)
            obj_.original_tagname_ = 'basecompoundref'
        elif nodeName_ == 'derivedcompoundref':
            obj_ = compoundRefType.factory()
            obj_.build(child_)
            self.derivedcompoundref.append(obj_)
            obj_.original_tagname_ = 'derivedcompoundref'
        elif nodeName_ == 'includes':
            obj_ = incType.factory()
            obj_.build(child_)
            self.includes.append(obj_)
            obj_.original_tagname_ = 'includes'
        elif nodeName_ == 'includedby':
            obj_ = incType.factory()
            obj_.build(child_)
            self.includedby.append(obj_)
            obj_.original_tagname_ = 'includedby'
        elif nodeName_ == 'incdepgraph':
            obj_ = graphType.factory()
            obj_.build(child_)
            self.incdepgraph = obj_
            obj_.original_tagname_ = 'incdepgraph'
        elif nodeName_ == 'invincdepgraph':
            obj_ = graphType.factory()
            obj_.build(child_)
            self.invincdepgraph = obj_
            obj_.original_tagname_ = 'invincdepgraph'
        elif nodeName_ == 'innerdir':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innerdir.append(obj_)
            obj_.original_tagname_ = 'innerdir'
        elif nodeName_ == 'innerfile':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innerfile.append(obj_)
            obj_.original_tagname_ = 'innerfile'
        elif nodeName_ == 'innerclass':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innerclass.append(obj_)
            #self.namespaces.append(obj_.content_[0].getValue())
            obj_.original_tagname_ = 'innerclass'
        elif nodeName_ == 'innernamespace':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innernamespace.append(obj_)
            #self.namespaces.append(obj_.content_[0].getValue())
            obj_.original_tagname_ = 'innernamespace'
        elif nodeName_ == 'innerpage':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innerpage.append(obj_)
            obj_.original_tagname_ = 'innerpage'
        elif nodeName_ == 'innergroup':
            obj_ = refType.factory()
            obj_.build(child_)
            self.innergroup.append(obj_)
            obj_.original_tagname_ = 'innergroup'
        elif nodeName_ == 'templateparamlist':
            obj_ = templateparamlistType.factory()
            obj_.build(child_)
            self.templateparamlist = obj_
            obj_.original_tagname_ = 'templateparamlist'
        elif nodeName_ == 'sectiondef':
            obj_ = sectiondefType.factory()
            obj_.build(child_)
            self.sectiondef.append(obj_)
            obj_.original_tagname_ = 'sectiondef'
        elif nodeName_ == 'briefdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.briefdescription = obj_
            obj_.original_tagname_ = 'briefdescription'
        elif nodeName_ == 'detaileddescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.detaileddescription = obj_
            obj_.original_tagname_ = 'detaileddescription'
        elif nodeName_ == 'inheritancegraph':
            obj_ = graphType.factory()
            obj_.build(child_)
            self.inheritancegraph = obj_
            obj_.original_tagname_ = 'inheritancegraph'
        elif nodeName_ == 'collaborationgraph':
            obj_ = graphType.factory()
            obj_.build(child_)
            self.collaborationgraph = obj_
            obj_.original_tagname_ = 'collaborationgraph'
        elif nodeName_ == 'programlisting':
            obj_ = listingType.factory()
            obj_.build(child_)
            self.programlisting = obj_
            obj_.original_tagname_ = 'programlisting'
        elif nodeName_ == 'location':
            obj_ = locationType.factory()
            obj_.build(child_)
            self.location = obj_
            obj_.original_tagname_ = 'location'
        elif nodeName_ == 'listofallmembers':
            obj_ = listofallmembersType.factory()
            obj_.build(child_)
            self.listofallmembers = obj_
            obj_.original_tagname_ = 'listofallmembers'
# end class compounddefType


class listofallmembersType(GeneratedsSuper):
    node_type = "listofallmembers"

    subclass = None
    superclass = None
    def __init__(self, member=None):
        self.original_tagname_ = None
        if member is None:
            self.member = []
        else:
            self.member = member
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, listofallmembersType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if listofallmembersType.subclass:
            return listofallmembersType.subclass(*args_, **kwargs_)
        else:
            return listofallmembersType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_member(self): return self.member
    def set_member(self, member): self.member = member
    def add_member(self, value): self.member.append(value)
    def insert_member_at(self, index, value): self.member.insert(index, value)
    def replace_member_at(self, index, value): self.member[index] = value
    def hasContent_(self):
        if (
            self.member
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='listofallmembersType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('listofallmembersType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='listofallmembersType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='listofallmembersType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='listofallmembersType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='listofallmembersType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for member_ in self.member:
            member_.export(outfile, level, namespace_, name_='member', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'member':
            obj_ = memberRefType.factory()
            obj_.build(child_)
            self.member.append(obj_)
            obj_.original_tagname_ = 'member'
# end class listofallmembersType


class memberRefType(GeneratedsSuper):
    node_type = "memberref"

    subclass = None
    superclass = None
    def __init__(self, refid=None, prot=None, virt=None, ambiguityscope=None, scope=None, name=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.prot = _cast(None, prot)
        self.virt = _cast(None, virt)
        self.ambiguityscope = _cast(None, ambiguityscope)
        self.scope = scope
        self.name = name
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, memberRefType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if memberRefType.subclass:
            return memberRefType.subclass(*args_, **kwargs_)
        else:
            return memberRefType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_scope(self): return self.scope
    def set_scope(self, scope): self.scope = scope
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_virt(self): return self.virt
    def set_virt(self, virt): self.virt = virt
    def get_ambiguityscope(self): return self.ambiguityscope
    def set_ambiguityscope(self, ambiguityscope): self.ambiguityscope = ambiguityscope
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxVirtualKind(self, value):
        # Validate type DoxVirtualKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['non-virtual', 'virtual', 'pure-virtual']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.scope is not None or
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='memberRefType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('memberRefType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='memberRefType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='memberRefType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='memberRefType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
        if self.virt is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            outfile.write(' virt=%s' % (quote_attrib(self.virt), ))
        if self.ambiguityscope is not None and 'ambiguityscope' not in already_processed:
            already_processed.add('ambiguityscope')
            outfile.write(' ambiguityscope=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.ambiguityscope), input_name='ambiguityscope')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='memberRefType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.scope is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<scope>%s</scope>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.scope), input_name='scope')), eol_))
        if self.name is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<name>%s</name>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), eol_))
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
        value = find_attr_value_('virt', node)
        if value is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            self.virt = value
            self.validate_DoxVirtualKind(self.virt)    # validate type DoxVirtualKind
        value = find_attr_value_('ambiguityscope', node)
        if value is not None and 'ambiguityscope' not in already_processed:
            already_processed.add('ambiguityscope')
            self.ambiguityscope = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'scope':
            scope_ = child_.text
            scope_ = self.gds_validate_string(scope_, node, 'scope')
            self.scope = scope_
        elif nodeName_ == 'name':
            name_ = child_.text
            name_ = self.gds_validate_string(name_, node, 'name')
            self.name = name_
# end class memberRefType


class scope(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, scope)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if scope.subclass:
            return scope.subclass(*args_, **kwargs_)
        else:
            return scope(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='scope', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('scope')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='scope')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='scope', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='scope'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='scope', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class scope


class name(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, name)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if name.subclass:
            return name.subclass(*args_, **kwargs_)
        else:
            return name(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='name', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('name')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='name')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='name', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='name'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='name', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class name


class compoundRefType(GeneratedsSuper):
    node_type = "compoundref"

    subclass = None
    superclass = None
    def __init__(self, refid=None, prot=None, virt=None, valueOf_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.prot = _cast(None, prot)
        self.virt = _cast(None, virt)
        self.valueOf_ = valueOf_
        self.mixedclass_ = MixedContainer
        self.content_ = []
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, compoundRefType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if compoundRefType.subclass:
            return compoundRefType.subclass(*args_, **kwargs_)
        else:
            return compoundRefType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_virt(self): return self.virt
    def set_virt(self, virt): self.virt = virt
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxVirtualKind(self, value):
        # Validate type DoxVirtualKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['non-virtual', 'virtual', 'pure-virtual']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='compoundRefType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('compoundRefType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='compoundRefType')
        if self.hasContent_():
            outfile.write('>')
            outfile.write(self.convert_unicode(self.valueOf_))
            self.exportChildren(outfile, level + 1, namespace_='', name_='compoundRefType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='compoundRefType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
        if self.virt is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            outfile.write(' virt=%s' % (quote_attrib(self.virt), ))
    def exportChildren(self, outfile, level, namespace_='', name_='compoundRefType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
        value = find_attr_value_('virt', node)
        if value is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            self.virt = value
            self.validate_DoxVirtualKind(self.virt)    # validate type DoxVirtualKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if child_.nodeType == Node.TEXT_NODE:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.nodeValue)
            self.content_.append(obj_)
        if child_.nodeType == Node.TEXT_NODE:
            self.valueOf_ += child_.nodeValue
        elif child_.nodeType == Node.CDATA_SECTION_NODE:
            self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
# end class compoundRefType


class reimplementType(GeneratedsSuper):
    node_type = "reimplement"

    subclass = None
    superclass = None
    def __init__(self, refid=None, valueOf_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, reimplementType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if reimplementType.subclass:
            return reimplementType.subclass(*args_, **kwargs_)
        else:
            return reimplementType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='reimplementType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('reimplementType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='reimplementType')
        if self.hasContent_():
            outfile.write('>')
            outfile.write(self.convert_unicode(self.valueOf_))
            self.exportChildren(outfile, level + 1, namespace_='', name_='reimplementType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='reimplementType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='reimplementType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class reimplementType


class incType(GeneratedsSuper):
    node_type = "inc"

    subclass = None
    superclass = None
    def __init__(self, refid=None, local=None, valueOf_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.local = _cast(None, local)
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, incType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if incType.subclass:
            return incType.subclass(*args_, **kwargs_)
        else:
            return incType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_local(self): return self.local
    def set_local(self, local): self.local = local
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxBool(self, value):
        # Validate type DoxBool, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['yes', 'no']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxBool' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='incType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('incType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='incType')
        if self.hasContent_():
            outfile.write('>')
            outfile.write(self.convert_unicode(self.valueOf_))
            self.exportChildren(outfile, level + 1, namespace_='', name_='incType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='incType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.local is not None and 'local' not in already_processed:
            already_processed.add('local')
            outfile.write(' local=%s' % (quote_attrib(self.local), ))
    def exportChildren(self, outfile, level, namespace_='', name_='incType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('local', node)
        if value is not None and 'local' not in already_processed:
            already_processed.add('local')
            self.local = value
            self.validate_DoxBool(self.local)    # validate type DoxBool
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class incType


class refType(GeneratedsSuper):
    node_type = "ref"

    subclass = None
    superclass = None
    def __init__(self, refid=None, prot=None, valueOf_=None):
        self.node_name = None
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.prot = _cast(None, prot)
        self.valueOf_ = valueOf_
        self.mixedclass_ = MixedContainer
        self.content_ = []
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, refType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if refType.subclass:
            return refType.subclass(*args_, **kwargs_)
        else:
            return refType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='refType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('refType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='refType')
        if self.hasContent_():
            outfile.write('>')
            outfile.write(self.convert_unicode(self.valueOf_))
            self.exportChildren(outfile, level + 1, namespace_='', name_='refType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='refType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
    def exportChildren(self, outfile, level, namespace_='', name_='refType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if child_.nodeType == Node.TEXT_NODE:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.nodeValue)
            self.content_.append(obj_)
        if child_.nodeType == Node.TEXT_NODE:
            self.valueOf_ += child_.nodeValue
        elif child_.nodeType == Node.CDATA_SECTION_NODE:
            self.valueOf_ += '![CDATA['+child_.nodeValue+']]'
# end class refType

class refTextType(GeneratedsSuper):
    node_type = "reftex"

    subclass = None
    superclass = None
    def __init__(self, refid=None, kindref=None, external=None, tooltip=None, valueOf_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.kindref = _cast(None, kindref)
        self.external = _cast(None, external)
        self.tooltip = _cast(None, tooltip)
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, refTextType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if refTextType.subclass:
            return refTextType.subclass(*args_, **kwargs_)
        else:
            return refTextType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_kindref(self): return self.kindref
    def set_kindref(self, kindref): self.kindref = kindref
    def get_external(self): return self.external
    def set_external(self, external): self.external = external
    def get_tooltip(self): return self.tooltip
    def set_tooltip(self, tooltip): self.tooltip = tooltip
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxRefKind(self, value):
        # Validate type DoxRefKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['compound', 'member']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxRefKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='refTextType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('refTextType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='refTextType')
        if self.hasContent_():
            outfile.write('>')
            outfile.write(self.convert_unicode(self.valueOf_))
            self.exportChildren(outfile, level + 1, namespace_='', name_='refTextType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='refTextType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.kindref is not None and 'kindref' not in already_processed:
            already_processed.add('kindref')
            outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))
        if self.external is not None and 'external' not in already_processed:
            already_processed.add('external')
            outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), ))
        if self.tooltip is not None and 'tooltip' not in already_processed:
            already_processed.add('tooltip')
            outfile.write(' tooltip=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.tooltip), input_name='tooltip')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='refTextType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('kindref', node)
        if value is not None and 'kindref' not in already_processed:
            already_processed.add('kindref')
            self.kindref = value
            self.validate_DoxRefKind(self.kindref)    # validate type DoxRefKind
        value = find_attr_value_('external', node)
        if value is not None and 'external' not in already_processed:
            already_processed.add('external')
            self.external = value
        value = find_attr_value_('tooltip', node)
        if value is not None and 'tooltip' not in already_processed:
            already_processed.add('tooltip')
            self.tooltip = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class refTextType


class sectiondefType(GeneratedsSuper):
    node_type = "sectiondef"

    subclass = None
    superclass = None
    def __init__(self, kind=None, header=None, description=None, memberdef=None):
        self.original_tagname_ = None
        self.kind = _cast(None, kind)
        self.header = header
        self.description = description
        if memberdef is None:
            self.memberdef = []
        else:
            self.memberdef = memberdef
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, sectiondefType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if sectiondefType.subclass:
            return sectiondefType.subclass(*args_, **kwargs_)
        else:
            return sectiondefType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_header(self): return self.header
    def set_header(self, header): self.header = header
    def get_description(self): return self.description
    def set_description(self, description): self.description = description
    def get_memberdef(self): return self.memberdef
    def set_memberdef(self, memberdef): self.memberdef = memberdef
    def add_memberdef(self, value): self.memberdef.append(value)
    def insert_memberdef_at(self, index, value): self.memberdef.insert(index, value)
    def replace_memberdef_at(self, index, value): self.memberdef[index] = value
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def validate_DoxSectionKind(self, value):
        # Validate type DoxSectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['user-defined', 'public-type', 'public-func', 'public-attrib', 'public-slot', 'signal', 'dcop-func', 'property', 'event', 'public-static-func', 'public-static-attrib', 'protected-type', 'protected-func', 'protected-attrib', 'protected-slot', 'protected-static-func', 'protected-static-attrib', 'package-type', 'package-func', 'package-attrib', 'package-static-func', 'package-static-attrib', 'private-type', 'private-func', 'private-attrib', 'private-slot', 'private-static-func', 'private-static-attrib', 'friend', 'related', 'define', 'prototype', 'typedef', 'enum', 'func', 'var']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxSectionKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.header is not None or
            self.description is not None or
            self.memberdef
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='sectiondefType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('sectiondefType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='sectiondefType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='sectiondefType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='sectiondefType'):
        if self.kind is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
    def exportChildren(self, outfile, level, namespace_='', name_='sectiondefType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.header is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<header>%s</header>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.header), input_name='header')), eol_))
        if self.description is not None:
            self.description.export(outfile, level, namespace_, name_='description', pretty_print=pretty_print)
        for memberdef_ in self.memberdef:
            memberdef_.export(outfile, level, namespace_, name_='memberdef', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('kind', node)
        if value is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            self.kind = value
            self.validate_DoxSectionKind(self.kind)    # validate type DoxSectionKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'header':
            header_ = child_.text
            header_ = self.gds_validate_string(header_, node, 'header')
            self.header = header_
        elif nodeName_ == 'description':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.description = obj_
            obj_.original_tagname_ = 'description'
        elif nodeName_ == 'memberdef':
            obj_ = memberdefType.factory()
            obj_.build(child_)
            self.memberdef.append(obj_)
            obj_.original_tagname_ = 'memberdef'
# end class sectiondefType


class memberdefType(GeneratedsSuper):
    node_type = "memberdef"

    subclass = None
    superclass = None
    def __init__(self, kind=None, id=None, prot=None, static=None, const=None, explicit=None, inline=None, refqual=None, virt=None, volatile=None, mutable=None, readable=None, writable=None, initonly=None, settable=None, gettable=None, final=None, sealed=None, new=None, add=None, remove=None, raise_=None, optional=None, required=None, accessor=None, attribute=None, property=None, readonly=None, bound=None, removable=None, contrained=None, transient=None, maybevoid=None, maybedefault=None, maybeambiguous=None, templateparamlist=None, type_=None, definition=None, argsstring=None, name=None, read=None, write=None, bitfield=None, reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):
        self.original_tagname_ = None
        self.kind = _cast(None, kind)
        self.id = _cast(None, id)
        self.prot = _cast(None, prot)
        self.static = _cast(None, static)
        self.const = _cast(None, const)
        self.explicit = _cast(None, explicit)
        self.inline = _cast(None, inline)
        self.refqual = _cast(None, refqual)
        self.virt = _cast(None, virt)
        self.volatile = _cast(None, volatile)
        self.mutable = _cast(None, mutable)
        self.readable = _cast(None, readable)
        self.writable = _cast(None, writable)
        self.initonly = _cast(None, initonly)
        self.settable = _cast(None, settable)
        self.gettable = _cast(None, gettable)
        self.final = _cast(None, final)
        self.sealed = _cast(None, sealed)
        self.new = _cast(None, new)
        self.add = _cast(None, add)
        self.remove = _cast(None, remove)
        self.raise_ = _cast(None, raise_)
        self.optional = _cast(None, optional)
        self.required = _cast(None, required)
        self.accessor = _cast(None, accessor)
        self.attribute = _cast(None, attribute)
        self.property = _cast(None, property)
        self.readonly = _cast(None, readonly)
        self.bound = _cast(None, bound)
        self.removable = _cast(None, removable)
        self.contrained = _cast(None, contrained)
        self.transient = _cast(None, transient)
        self.maybevoid = _cast(None, maybevoid)
        self.maybedefault = _cast(None, maybedefault)
        self.maybeambiguous = _cast(None, maybeambiguous)
        self.templateparamlist = templateparamlist
        self.type_ = type_
        self.definition = definition
        self.argsstring = argsstring
        self.name = name
        self.read = read
        self.write = write
        self.bitfield = bitfield
        if reimplements is None:
            self.reimplements = []
        else:
            self.reimplements = reimplements
        if reimplementedby is None:
            self.reimplementedby = []
        else:
            self.reimplementedby = reimplementedby
        if param is None:
            self.param = []
        else:
            self.param = param
        if enumvalue is None:
            self.enumvalue = []
        else:
            self.enumvalue = enumvalue
        self.initializer = initializer
        self.exceptions = exceptions
        self.briefdescription = briefdescription
        self.detaileddescription = detaileddescription
        self.inbodydescription = inbodydescription
        self.location = location
        if references is None:
            self.references = []
        else:
            self.references = references
        if referencedby is None:
            self.referencedby = []
        else:
            self.referencedby = referencedby
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, memberdefType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if memberdefType.subclass:
            return memberdefType.subclass(*args_, **kwargs_)
        else:
            return memberdefType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_templateparamlist(self): return self.templateparamlist
    def set_templateparamlist(self, templateparamlist): self.templateparamlist = templateparamlist
    def get_type(self): return self.type_
    def set_type(self, type_): self.type_ = type_
    def get_definition(self): return self.definition
    def set_definition(self, definition): self.definition = definition
    def get_argsstring(self): return self.argsstring
    def set_argsstring(self, argsstring): self.argsstring = argsstring
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_read(self): return self.read
    def set_read(self, read): self.read = read
    def get_write(self): return self.write
    def set_write(self, write): self.write = write
    def get_bitfield(self): return self.bitfield
    def set_bitfield(self, bitfield): self.bitfield = bitfield
    def get_reimplements(self): return self.reimplements
    def set_reimplements(self, reimplements): self.reimplements = reimplements
    def add_reimplements(self, value): self.reimplements.append(value)
    def insert_reimplements_at(self, index, value): self.reimplements.insert(index, value)
    def replace_reimplements_at(self, index, value): self.reimplements[index] = value
    def get_reimplementedby(self): return self.reimplementedby
    def set_reimplementedby(self, reimplementedby): self.reimplementedby = reimplementedby
    def add_reimplementedby(self, value): self.reimplementedby.append(value)
    def insert_reimplementedby_at(self, index, value): self.reimplementedby.insert(index, value)
    def replace_reimplementedby_at(self, index, value): self.reimplementedby[index] = value
    def get_param(self): return self.param
    def set_param(self, param): self.param = param
    def add_param(self, value): self.param.append(value)
    def insert_param_at(self, index, value): self.param.insert(index, value)
    def replace_param_at(self, index, value): self.param[index] = value
    def get_enumvalue(self): return self.enumvalue
    def set_enumvalue(self, enumvalue): self.enumvalue = enumvalue
    def add_enumvalue(self, value): self.enumvalue.append(value)
    def insert_enumvalue_at(self, index, value): self.enumvalue.insert(index, value)
    def replace_enumvalue_at(self, index, value): self.enumvalue[index] = value
    def get_initializer(self): return self.initializer
    def set_initializer(self, initializer): self.initializer = initializer
    def get_exceptions(self): return self.exceptions
    def set_exceptions(self, exceptions): self.exceptions = exceptions
    def get_briefdescription(self): return self.briefdescription
    def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
    def get_detaileddescription(self): return self.detaileddescription
    def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
    def get_inbodydescription(self): return self.inbodydescription
    def set_inbodydescription(self, inbodydescription): self.inbodydescription = inbodydescription
    def get_location(self): return self.location
    def set_location(self, location): self.location = location
    def get_references(self): return self.references
    def set_references(self, references): self.references = references
    def add_references(self, value): self.references.append(value)
    def insert_references_at(self, index, value): self.references.insert(index, value)
    def replace_references_at(self, index, value): self.references[index] = value
    def get_referencedby(self): return self.referencedby
    def set_referencedby(self, referencedby): self.referencedby = referencedby
    def add_referencedby(self, value): self.referencedby.append(value)
    def insert_referencedby_at(self, index, value): self.referencedby.insert(index, value)
    def replace_referencedby_at(self, index, value): self.referencedby[index] = value
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_static(self): return self.static
    def set_static(self, static): self.static = static
    def get_const(self): return self.const
    def set_const(self, const): self.const = const
    def get_explicit(self): return self.explicit
    def set_explicit(self, explicit): self.explicit = explicit
    def get_inline(self): return self.inline
    def set_inline(self, inline): self.inline = inline
    def get_refqual(self): return self.refqual
    def set_refqual(self, refqual): self.refqual = refqual
    def get_virt(self): return self.virt
    def set_virt(self, virt): self.virt = virt
    def get_volatile(self): return self.volatile
    def set_volatile(self, volatile): self.volatile = volatile
    def get_mutable(self): return self.mutable
    def set_mutable(self, mutable): self.mutable = mutable
    def get_readable(self): return self.readable
    def set_readable(self, readable): self.readable = readable
    def get_writable(self): return self.writable
    def set_writable(self, writable): self.writable = writable
    def get_initonly(self): return self.initonly
    def set_initonly(self, initonly): self.initonly = initonly
    def get_settable(self): return self.settable
    def set_settable(self, settable): self.settable = settable
    def get_gettable(self): return self.gettable
    def set_gettable(self, gettable): self.gettable = gettable
    def get_final(self): return self.final
    def set_final(self, final): self.final = final
    def get_sealed(self): return self.sealed
    def set_sealed(self, sealed): self.sealed = sealed
    def get_new(self): return self.new
    def set_new(self, new): self.new = new
    def get_add(self): return self.add
    def set_add(self, add): self.add = add
    def get_remove(self): return self.remove
    def set_remove(self, remove): self.remove = remove
    def get_raise(self): return self.raise_
    def set_raise(self, raise_): self.raise_ = raise_
    def get_optional(self): return self.optional
    def set_optional(self, optional): self.optional = optional
    def get_required(self): return self.required
    def set_required(self, required): self.required = required
    def get_accessor(self): return self.accessor
    def set_accessor(self, accessor): self.accessor = accessor
    def get_attribute(self): return self.attribute
    def set_attribute(self, attribute): self.attribute = attribute
    def get_property(self): return self.property
    def set_property(self, property): self.property = property
    def get_readonly(self): return self.readonly
    def set_readonly(self, readonly): self.readonly = readonly
    def get_bound(self): return self.bound
    def set_bound(self, bound): self.bound = bound
    def get_removable(self): return self.removable
    def set_removable(self, removable): self.removable = removable
    def get_contrained(self): return self.contrained
    def set_contrained(self, contrained): self.contrained = contrained
    def get_transient(self): return self.transient
    def set_transient(self, transient): self.transient = transient
    def get_maybevoid(self): return self.maybevoid
    def set_maybevoid(self, maybevoid): self.maybevoid = maybevoid
    def get_maybedefault(self): return self.maybedefault
    def set_maybedefault(self, maybedefault): self.maybedefault = maybedefault
    def get_maybeambiguous(self): return self.maybeambiguous
    def set_maybeambiguous(self, maybeambiguous): self.maybeambiguous = maybeambiguous
    def validate_DoxMemberKind(self, value):
        # Validate type DoxMemberKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['define', 'property', 'event', 'variable', 'typedef', 'enum', 'function', 'signal', 'prototype', 'friend', 'dcop', 'slot', 'interface', 'service']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxMemberKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxBool(self, value):
        # Validate type DoxBool, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['yes', 'no']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxBool' % {"value" : value.encode("utf-8")} )
    def validate_DoxRefQualifierKind(self, value):
        # Validate type DoxRefQualifierKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['lvalue', 'rvalue']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxRefQualifierKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxVirtualKind(self, value):
        # Validate type DoxVirtualKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['non-virtual', 'virtual', 'pure-virtual']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxVirtualKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxAccessor(self, value):
        # Validate type DoxAccessor, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['retain', 'copy', 'assign', 'weak', 'strong', 'unretained']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxAccessor' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.templateparamlist is not None or
            self.type_ is not None or
            self.definition is not None or
            self.argsstring is not None or
            self.name is not None or
            self.read is not None or
            self.write is not None or
            self.bitfield is not None or
            self.reimplements or
            self.reimplementedby or
            self.param or
            self.enumvalue or
            self.initializer is not None or
            self.exceptions is not None or
            self.briefdescription is not None or
            self.detaileddescription is not None or
            self.inbodydescription is not None or
            self.location is not None or
            self.references or
            self.referencedby
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='memberdefType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('memberdefType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='memberdefType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='memberdefType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='memberdefType'):
        if self.kind is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
        if self.static is not None and 'static' not in already_processed:
            already_processed.add('static')
            outfile.write(' static=%s' % (quote_attrib(self.static), ))
        if self.const is not None and 'const' not in already_processed:
            already_processed.add('const')
            outfile.write(' const=%s' % (quote_attrib(self.const), ))
        if self.explicit is not None and 'explicit' not in already_processed:
            already_processed.add('explicit')
            outfile.write(' explicit=%s' % (quote_attrib(self.explicit), ))
        if self.inline is not None and 'inline' not in already_processed:
            already_processed.add('inline')
            outfile.write(' inline=%s' % (quote_attrib(self.inline), ))
        if self.refqual is not None and 'refqual' not in already_processed:
            already_processed.add('refqual')
            outfile.write(' refqual=%s' % (quote_attrib(self.refqual), ))
        if self.virt is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            outfile.write(' virt=%s' % (quote_attrib(self.virt), ))
        if self.volatile is not None and 'volatile' not in already_processed:
            already_processed.add('volatile')
            outfile.write(' volatile=%s' % (quote_attrib(self.volatile), ))
        if self.mutable is not None and 'mutable' not in already_processed:
            already_processed.add('mutable')
            outfile.write(' mutable=%s' % (quote_attrib(self.mutable), ))
        if self.readable is not None and 'readable' not in already_processed:
            already_processed.add('readable')
            outfile.write(' readable=%s' % (quote_attrib(self.readable), ))
        if self.writable is not None and 'writable' not in already_processed:
            already_processed.add('writable')
            outfile.write(' writable=%s' % (quote_attrib(self.writable), ))
        if self.initonly is not None and 'initonly' not in already_processed:
            already_processed.add('initonly')
            outfile.write(' initonly=%s' % (quote_attrib(self.initonly), ))
        if self.settable is not None and 'settable' not in already_processed:
            already_processed.add('settable')
            outfile.write(' settable=%s' % (quote_attrib(self.settable), ))
        if self.gettable is not None and 'gettable' not in already_processed:
            already_processed.add('gettable')
            outfile.write(' gettable=%s' % (quote_attrib(self.gettable), ))
        if self.final is not None and 'final' not in already_processed:
            already_processed.add('final')
            outfile.write(' final=%s' % (quote_attrib(self.final), ))
        if self.sealed is not None and 'sealed' not in already_processed:
            already_processed.add('sealed')
            outfile.write(' sealed=%s' % (quote_attrib(self.sealed), ))
        if self.new is not None and 'new' not in already_processed:
            already_processed.add('new')
            outfile.write(' new=%s' % (quote_attrib(self.new), ))
        if self.add is not None and 'add' not in already_processed:
            already_processed.add('add')
            outfile.write(' add=%s' % (quote_attrib(self.add), ))
        if self.remove is not None and 'remove' not in already_processed:
            already_processed.add('remove')
            outfile.write(' remove=%s' % (quote_attrib(self.remove), ))
        if self.raise_ is not None and 'raise_' not in already_processed:
            already_processed.add('raise_')
            outfile.write(' raise=%s' % (quote_attrib(self.raise_), ))
        if self.optional is not None and 'optional' not in already_processed:
            already_processed.add('optional')
            outfile.write(' optional=%s' % (quote_attrib(self.optional), ))
        if self.required is not None and 'required' not in already_processed:
            already_processed.add('required')
            outfile.write(' required=%s' % (quote_attrib(self.required), ))
        if self.accessor is not None and 'accessor' not in already_processed:
            already_processed.add('accessor')
            outfile.write(' accessor=%s' % (quote_attrib(self.accessor), ))
        if self.attribute is not None and 'attribute' not in already_processed:
            already_processed.add('attribute')
            outfile.write(' attribute=%s' % (quote_attrib(self.attribute), ))
        if self.property is not None and 'property' not in already_processed:
            already_processed.add('property')
            outfile.write(' property=%s' % (quote_attrib(self.property), ))
        if self.readonly is not None and 'readonly' not in already_processed:
            already_processed.add('readonly')
            outfile.write(' readonly=%s' % (quote_attrib(self.readonly), ))
        if self.bound is not None and 'bound' not in already_processed:
            already_processed.add('bound')
            outfile.write(' bound=%s' % (quote_attrib(self.bound), ))
        if self.removable is not None and 'removable' not in already_processed:
            already_processed.add('removable')
            outfile.write(' removable=%s' % (quote_attrib(self.removable), ))
        if self.contrained is not None and 'contrained' not in already_processed:
            already_processed.add('contrained')
            outfile.write(' contrained=%s' % (quote_attrib(self.contrained), ))
        if self.transient is not None and 'transient' not in already_processed:
            already_processed.add('transient')
            outfile.write(' transient=%s' % (quote_attrib(self.transient), ))
        if self.maybevoid is not None and 'maybevoid' not in already_processed:
            already_processed.add('maybevoid')
            outfile.write(' maybevoid=%s' % (quote_attrib(self.maybevoid), ))
        if self.maybedefault is not None and 'maybedefault' not in already_processed:
            already_processed.add('maybedefault')
            outfile.write(' maybedefault=%s' % (quote_attrib(self.maybedefault), ))
        if self.maybeambiguous is not None and 'maybeambiguous' not in already_processed:
            already_processed.add('maybeambiguous')
            outfile.write(' maybeambiguous=%s' % (quote_attrib(self.maybeambiguous), ))
    def exportChildren(self, outfile, level, namespace_='', name_='memberdefType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.templateparamlist is not None:
            self.templateparamlist.export(outfile, level, namespace_, name_='templateparamlist', pretty_print=pretty_print)
        if self.type_ is not None:
            self.type_.export(outfile, level, namespace_, name_='type', pretty_print=pretty_print)
        if self.definition is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<definition>%s</definition>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.definition), input_name='definition')), eol_))
        if self.argsstring is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<argsstring>%s</argsstring>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.argsstring), input_name='argsstring')), eol_))
        if self.name is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<name>%s</name>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), eol_))
        if self.read is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<read>%s</read>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.read), input_name='read')), eol_))
        if self.write is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<write>%s</write>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.write), input_name='write')), eol_))
        if self.bitfield is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<bitfield>%s</bitfield>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.bitfield), input_name='bitfield')), eol_))
        for reimplements_ in self.reimplements:
            reimplements_.export(outfile, level, namespace_, name_='reimplements', pretty_print=pretty_print)
        for reimplementedby_ in self.reimplementedby:
            reimplementedby_.export(outfile, level, namespace_, name_='reimplementedby', pretty_print=pretty_print)
        for param_ in self.param:
            param_.export(outfile, level, namespace_, name_='param', pretty_print=pretty_print)
        for enumvalue_ in self.enumvalue:
            enumvalue_.export(outfile, level, namespace_, name_='enumvalue', pretty_print=pretty_print)
        if self.initializer is not None:
            self.initializer.export(outfile, level, namespace_, name_='initializer', pretty_print=pretty_print)
        if self.exceptions is not None:
            self.exceptions.export(outfile, level, namespace_, name_='exceptions', pretty_print=pretty_print)
        if self.briefdescription is not None:
            self.briefdescription.export(outfile, level, namespace_, name_='briefdescription', pretty_print=pretty_print)
        if self.detaileddescription is not None:
            self.detaileddescription.export(outfile, level, namespace_, name_='detaileddescription', pretty_print=pretty_print)
        if self.inbodydescription is not None:
            self.inbodydescription.export(outfile, level, namespace_, name_='inbodydescription', pretty_print=pretty_print)
        if self.location is not None:
            self.location.export(outfile, level, namespace_, name_='location', pretty_print=pretty_print)
        for references_ in self.references:
            references_.export(outfile, level, namespace_, name_='references', pretty_print=pretty_print)
        for referencedby_ in self.referencedby:
            referencedby_.export(outfile, level, namespace_, name_='referencedby', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('kind', node)
        if value is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            self.kind = value
            self.validate_DoxMemberKind(self.kind)    # validate type DoxMemberKind
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
        value = find_attr_value_('static', node)
        if value is not None and 'static' not in already_processed:
            already_processed.add('static')
            self.static = value
            self.validate_DoxBool(self.static)    # validate type DoxBool
        value = find_attr_value_('const', node)
        if value is not None and 'const' not in already_processed:
            already_processed.add('const')
            self.const = value
            self.validate_DoxBool(self.const)    # validate type DoxBool
        value = find_attr_value_('explicit', node)
        if value is not None and 'explicit' not in already_processed:
            already_processed.add('explicit')
            self.explicit = value
            self.validate_DoxBool(self.explicit)    # validate type DoxBool
        value = find_attr_value_('inline', node)
        if value is not None and 'inline' not in already_processed:
            already_processed.add('inline')
            self.inline = value
            self.validate_DoxBool(self.inline)    # validate type DoxBool
        value = find_attr_value_('refqual', node)
        if value is not None and 'refqual' not in already_processed:
            already_processed.add('refqual')
            self.refqual = value
            self.validate_DoxRefQualifierKind(self.refqual)    # validate type DoxRefQualifierKind
        value = find_attr_value_('virt', node)
        if value is not None and 'virt' not in already_processed:
            already_processed.add('virt')
            self.virt = value
            self.validate_DoxVirtualKind(self.virt)    # validate type DoxVirtualKind
        value = find_attr_value_('volatile', node)
        if value is not None and 'volatile' not in already_processed:
            already_processed.add('volatile')
            self.volatile = value
            self.validate_DoxBool(self.volatile)    # validate type DoxBool
        value = find_attr_value_('mutable', node)
        if value is not None and 'mutable' not in already_processed:
            already_processed.add('mutable')
            self.mutable = value
            self.validate_DoxBool(self.mutable)    # validate type DoxBool
        value = find_attr_value_('readable', node)
        if value is not None and 'readable' not in already_processed:
            already_processed.add('readable')
            self.readable = value
            self.validate_DoxBool(self.readable)    # validate type DoxBool
        value = find_attr_value_('writable', node)
        if value is not None and 'writable' not in already_processed:
            already_processed.add('writable')
            self.writable = value
            self.validate_DoxBool(self.writable)    # validate type DoxBool
        value = find_attr_value_('initonly', node)
        if value is not None and 'initonly' not in already_processed:
            already_processed.add('initonly')
            self.initonly = value
            self.validate_DoxBool(self.initonly)    # validate type DoxBool
        value = find_attr_value_('settable', node)
        if value is not None and 'settable' not in already_processed:
            already_processed.add('settable')
            self.settable = value
            self.validate_DoxBool(self.settable)    # validate type DoxBool
        value = find_attr_value_('gettable', node)
        if value is not None and 'gettable' not in already_processed:
            already_processed.add('gettable')
            self.gettable = value
            self.validate_DoxBool(self.gettable)    # validate type DoxBool
        value = find_attr_value_('final', node)
        if value is not None and 'final' not in already_processed:
            already_processed.add('final')
            self.final = value
            self.validate_DoxBool(self.final)    # validate type DoxBool
        value = find_attr_value_('sealed', node)
        if value is not None and 'sealed' not in already_processed:
            already_processed.add('sealed')
            self.sealed = value
            self.validate_DoxBool(self.sealed)    # validate type DoxBool
        value = find_attr_value_('new', node)
        if value is not None and 'new' not in already_processed:
            already_processed.add('new')
            self.new = value
            self.validate_DoxBool(self.new)    # validate type DoxBool
        value = find_attr_value_('add', node)
        if value is not None and 'add' not in already_processed:
            already_processed.add('add')
            self.add = value
            self.validate_DoxBool(self.add)    # validate type DoxBool
        value = find_attr_value_('remove', node)
        if value is not None and 'remove' not in already_processed:
            already_processed.add('remove')
            self.remove = value
            self.validate_DoxBool(self.remove)    # validate type DoxBool
        value = find_attr_value_('raise', node)
        if value is not None and 'raise' not in already_processed:
            already_processed.add('raise')
            self.raise_ = value
            self.validate_DoxBool(self.raise_)    # validate type DoxBool
        value = find_attr_value_('optional', node)
        if value is not None and 'optional' not in already_processed:
            already_processed.add('optional')
            self.optional = value
            self.validate_DoxBool(self.optional)    # validate type DoxBool
        value = find_attr_value_('required', node)
        if value is not None and 'required' not in already_processed:
            already_processed.add('required')
            self.required = value
            self.validate_DoxBool(self.required)    # validate type DoxBool
        value = find_attr_value_('accessor', node)
        if value is not None and 'accessor' not in already_processed:
            already_processed.add('accessor')
            self.accessor = value
            self.validate_DoxAccessor(self.accessor)    # validate type DoxAccessor
        value = find_attr_value_('attribute', node)
        if value is not None and 'attribute' not in already_processed:
            already_processed.add('attribute')
            self.attribute = value
            self.validate_DoxBool(self.attribute)    # validate type DoxBool
        value = find_attr_value_('property', node)
        if value is not None and 'property' not in already_processed:
            already_processed.add('property')
            self.property = value
            self.validate_DoxBool(self.property)    # validate type DoxBool
        value = find_attr_value_('readonly', node)
        if value is not None and 'readonly' not in already_processed:
            already_processed.add('readonly')
            self.readonly = value
            self.validate_DoxBool(self.readonly)    # validate type DoxBool
        value = find_attr_value_('bound', node)
        if value is not None and 'bound' not in already_processed:
            already_processed.add('bound')
            self.bound = value
            self.validate_DoxBool(self.bound)    # validate type DoxBool
        value = find_attr_value_('removable', node)
        if value is not None and 'removable' not in already_processed:
            already_processed.add('removable')
            self.removable = value
            self.validate_DoxBool(self.removable)    # validate type DoxBool
        value = find_attr_value_('contrained', node)
        if value is not None and 'contrained' not in already_processed:
            already_processed.add('contrained')
            self.contrained = value
            self.validate_DoxBool(self.contrained)    # validate type DoxBool
        value = find_attr_value_('transient', node)
        if value is not None and 'transient' not in already_processed:
            already_processed.add('transient')
            self.transient = value
            self.validate_DoxBool(self.transient)    # validate type DoxBool
        value = find_attr_value_('maybevoid', node)
        if value is not None and 'maybevoid' not in already_processed:
            already_processed.add('maybevoid')
            self.maybevoid = value
            self.validate_DoxBool(self.maybevoid)    # validate type DoxBool
        value = find_attr_value_('maybedefault', node)
        if value is not None and 'maybedefault' not in already_processed:
            already_processed.add('maybedefault')
            self.maybedefault = value
            self.validate_DoxBool(self.maybedefault)    # validate type DoxBool
        value = find_attr_value_('maybeambiguous', node)
        if value is not None and 'maybeambiguous' not in already_processed:
            already_processed.add('maybeambiguous')
            self.maybeambiguous = value
            self.validate_DoxBool(self.maybeambiguous)    # validate type DoxBool
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'templateparamlist':
            obj_ = templateparamlistType.factory()
            obj_.build(child_)
            self.templateparamlist = obj_
            obj_.original_tagname_ = 'templateparamlist'
        elif nodeName_ == 'type':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'definition':
            definition_ = child_.text
            definition_ = self.gds_validate_string(definition_, node, 'definition')
            self.definition = definition_
        elif nodeName_ == 'argsstring':
            argsstring_ = child_.text
            argsstring_ = self.gds_validate_string(argsstring_, node, 'argsstring')
            self.argsstring = argsstring_
        elif nodeName_ == 'name':
            name_ = child_.text
            name_ = self.gds_validate_string(name_, node, 'name')
            self.name = name_
        elif nodeName_ == 'read':
            read_ = child_.text
            read_ = self.gds_validate_string(read_, node, 'read')
            self.read = read_
        elif nodeName_ == 'write':
            write_ = child_.text
            write_ = self.gds_validate_string(write_, node, 'write')
            self.write = write_
        elif nodeName_ == 'bitfield':
            bitfield_ = child_.text
            bitfield_ = self.gds_validate_string(bitfield_, node, 'bitfield')
            self.bitfield = bitfield_
        elif nodeName_ == 'reimplements':
            obj_ = reimplementType.factory()
            obj_.build(child_)
            self.reimplements.append(obj_)
            obj_.original_tagname_ = 'reimplements'
        elif nodeName_ == 'reimplementedby':
            obj_ = reimplementType.factory()
            obj_.build(child_)
            self.reimplementedby.append(obj_)
            obj_.original_tagname_ = 'reimplementedby'
        elif nodeName_ == 'param':
            obj_ = paramType.factory()
            obj_.build(child_)
            self.param.append(obj_)
            obj_.original_tagname_ = 'param'
        elif nodeName_ == 'enumvalue':
            obj_ = enumvalueType.factory()
            obj_.build(child_)
            self.enumvalue.append(obj_)
            obj_.original_tagname_ = 'enumvalue'
        elif nodeName_ == 'initializer':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.initializer = obj_
            obj_.original_tagname_ = 'initializer'
        elif nodeName_ == 'exceptions':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.exceptions = obj_
            obj_.original_tagname_ = 'exceptions'
        elif nodeName_ == 'briefdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.briefdescription = obj_
            obj_.original_tagname_ = 'briefdescription'
        elif nodeName_ == 'detaileddescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.detaileddescription = obj_
            obj_.original_tagname_ = 'detaileddescription'
        elif nodeName_ == 'inbodydescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.inbodydescription = obj_
            obj_.original_tagname_ = 'inbodydescription'
        elif nodeName_ == 'location':
            obj_ = locationType.factory()
            obj_.build(child_)
            self.location = obj_
            obj_.original_tagname_ = 'location'
        elif nodeName_ == 'references':
            obj_ = referenceType.factory()
            obj_.build(child_)
            self.references.append(obj_)
            obj_.original_tagname_ = 'references'
        elif nodeName_ == 'referencedby':
            obj_ = referenceType.factory()
            obj_.build(child_)
            self.referencedby.append(obj_)
            obj_.original_tagname_ = 'referencedby'
# end class memberdefType


class definition(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, definition)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if definition.subclass:
            return definition.subclass(*args_, **kwargs_)
        else:
            return definition(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='definition', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('definition')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='definition')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='definition', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='definition'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='definition', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class definition


class argsstring(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, argsstring)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if argsstring.subclass:
            return argsstring.subclass(*args_, **kwargs_)
        else:
            return argsstring(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='argsstring', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('argsstring')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='argsstring')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='argsstring', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='argsstring'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='argsstring', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class argsstring


class read(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, read)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if read.subclass:
            return read.subclass(*args_, **kwargs_)
        else:
            return read(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='read', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('read')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='read')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='read', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='read'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='read', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class read


class write(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, write)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if write.subclass:
            return write.subclass(*args_, **kwargs_)
        else:
            return write(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='write', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('write')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='write')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='write', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='write'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='write', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class write


class bitfield(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, bitfield)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if bitfield.subclass:
            return bitfield.subclass(*args_, **kwargs_)
        else:
            return bitfield(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='bitfield', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('bitfield')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='bitfield')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='bitfield', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='bitfield'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='bitfield', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class bitfield


class descriptionType(GeneratedsSuper):
    node_type = "description"

    subclass = None
    superclass = None
    def __init__(self, title=None, para=None, sect1=None, internal=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect1 is None:
            self.sect1 = []
        else:
            self.sect1 = sect1
        self.internal = internal
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, descriptionType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if descriptionType.subclass:
            return descriptionType.subclass(*args_, **kwargs_)
        else:
            return descriptionType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect1(self): return self.sect1
    def set_sect1(self, sect1): self.sect1 = sect1
    def add_sect1(self, value): self.sect1.append(value)
    def insert_sect1_at(self, index, value): self.sect1.insert(index, value)
    def replace_sect1_at(self, index, value): self.sect1[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.title is not None or
            self.para or
            self.sect1 or
            self.internal is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='descriptionType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('descriptionType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='descriptionType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='descriptionType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='descriptionType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='descriptionType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect1_ in self.sect1:
            sect1_.export(outfile, level, namespace_, name_='sect1', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'title', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect1':
            obj_ = docSect1Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect1'):
              self.add_sect1(obj_.value)
            elif hasattr(self, 'set_sect1'):
              self.set_sect1(obj_.value)
        elif nodeName_ == 'internal':
            obj_ = docInternalType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'internal', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_internal'):
              self.add_internal(obj_.value)
            elif hasattr(self, 'set_internal'):
              self.set_internal(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class descriptionType


class enumvalueType(GeneratedsSuper):
    node_type = "enumvalue"

    subclass = None
    superclass = None
    def __init__(self, id=None, prot=None, name=None, initializer=None, briefdescription=None, detaileddescription=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.prot = _cast(None, prot)
        self.name = name
        self.initializer = initializer
        self.briefdescription = briefdescription
        self.detaileddescription = detaileddescription
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, enumvalueType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if enumvalueType.subclass:
            return enumvalueType.subclass(*args_, **kwargs_)
        else:
            return enumvalueType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_initializer(self): return self.initializer
    def set_initializer(self, initializer): self.initializer = initializer
    def get_briefdescription(self): return self.briefdescription
    def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
    def get_detaileddescription(self): return self.detaileddescription
    def set_detaileddescription(self, detaileddescription): self.detaileddescription = detaileddescription
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_prot(self): return self.prot
    def set_prot(self, prot): self.prot = prot
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxProtectionKind(self, value):
        # Validate type DoxProtectionKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['public', 'protected', 'private', 'package']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxProtectionKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.name is not None or
            self.initializer is not None or
            self.briefdescription is not None or
            self.detaileddescription is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='enumvalueType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('enumvalueType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='enumvalueType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='enumvalueType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='enumvalueType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
        if self.prot is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            outfile.write(' prot=%s' % (quote_attrib(self.prot), ))
    def exportChildren(self, outfile, level, namespace_='', name_='enumvalueType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<name>%s</name>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), eol_))
        if self.initializer is not None:
            self.initializer.export(outfile, level, namespace_, name_='initializer', pretty_print=pretty_print)
        if self.briefdescription is not None:
            self.briefdescription.export(outfile, level, namespace_, name_='briefdescription', pretty_print=pretty_print)
        if self.detaileddescription is not None:
            self.detaileddescription.export(outfile, level, namespace_, name_='detaileddescription', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
        value = find_attr_value_('prot', node)
        if value is not None and 'prot' not in already_processed:
            already_processed.add('prot')
            self.prot = value
            self.validate_DoxProtectionKind(self.prot)    # validate type DoxProtectionKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'name' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'name', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'initializer':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'initializer', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_initializer'):
              self.add_initializer(obj_.value)
            elif hasattr(self, 'set_initializer'):
              self.set_initializer(obj_.value)
        elif nodeName_ == 'briefdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'briefdescription', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_briefdescription'):
              self.add_briefdescription(obj_.value)
            elif hasattr(self, 'set_briefdescription'):
              self.set_briefdescription(obj_.value)
        elif nodeName_ == 'detaileddescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'detaileddescription', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_detaileddescription'):
              self.add_detaileddescription(obj_.value)
            elif hasattr(self, 'set_detaileddescription'):
              self.set_detaileddescription(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class enumvalueType


class templateparamlistType(GeneratedsSuper):
    node_type = "templateparamlist"

    subclass = None
    superclass = None
    def __init__(self, param=None):
        self.original_tagname_ = None
        if param is None:
            self.param = []
        else:
            self.param = param
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, templateparamlistType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if templateparamlistType.subclass:
            return templateparamlistType.subclass(*args_, **kwargs_)
        else:
            return templateparamlistType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_param(self): return self.param
    def set_param(self, param): self.param = param
    def add_param(self, value): self.param.append(value)
    def insert_param_at(self, index, value): self.param.insert(index, value)
    def replace_param_at(self, index, value): self.param[index] = value
    def hasContent_(self):
        if (
            self.param
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='templateparamlistType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('templateparamlistType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='templateparamlistType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='templateparamlistType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='templateparamlistType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='templateparamlistType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for param_ in self.param:
            param_.export(outfile, level, namespace_, name_='param', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'param':
            obj_ = paramType.factory()
            obj_.build(child_)
            self.param.append(obj_)
            obj_.original_tagname_ = 'param'
# end class templateparamlistType


class paramType(GeneratedsSuper):
    node_type = "param"

    subclass = None
    superclass = None
    def __init__(self, type_=None, declname=None, defname=None, array=None, defval=None, typeconstraint=None, briefdescription=None):
        self.original_tagname_ = None
        self.type_ = type_
        self.declname = declname
        self.defname = defname
        self.array = array
        self.defval = defval
        self.typeconstraint = typeconstraint
        self.briefdescription = briefdescription
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, paramType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if paramType.subclass:
            return paramType.subclass(*args_, **kwargs_)
        else:
            return paramType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_type(self): return self.type_
    def set_type(self, type_): self.type_ = type_
    def get_declname(self): return self.declname
    def set_declname(self, declname): self.declname = declname
    def get_defname(self): return self.defname
    def set_defname(self, defname): self.defname = defname
    def get_array(self): return self.array
    def set_array(self, array): self.array = array
    def get_defval(self): return self.defval
    def set_defval(self, defval): self.defval = defval
    def get_typeconstraint(self): return self.typeconstraint
    def set_typeconstraint(self, typeconstraint): self.typeconstraint = typeconstraint
    def get_briefdescription(self): return self.briefdescription
    def set_briefdescription(self, briefdescription): self.briefdescription = briefdescription
    def hasContent_(self):
        if (
            self.type_ is not None or
            self.declname is not None or
            self.defname is not None or
            self.array is not None or
            self.defval is not None or
            self.typeconstraint is not None or
            self.briefdescription is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='paramType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('paramType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='paramType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='paramType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='paramType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='paramType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.type_ is not None:
            self.type_.export(outfile, level, namespace_, name_='type', pretty_print=pretty_print)
        if self.declname is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<declname>%s</declname>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.declname), input_name='declname')), eol_))
        if self.defname is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<defname>%s</defname>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.defname), input_name='defname')), eol_))
        if self.array is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<array>%s</array>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.array), input_name='array')), eol_))
        if self.defval is not None:
            self.defval.export(outfile, level, namespace_, name_='defval', pretty_print=pretty_print)
        if self.typeconstraint is not None:
            self.typeconstraint.export(outfile, level, namespace_, name_='typeconstraint', pretty_print=pretty_print)
        if self.briefdescription is not None:
            self.briefdescription.export(outfile, level, namespace_, name_='briefdescription', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'type':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.type_ = obj_
            obj_.original_tagname_ = 'type'
        elif nodeName_ == 'declname':
            declname_ = child_.text
            declname_ = self.gds_validate_string(declname_, node, 'declname')
            self.declname = declname_
        elif nodeName_ == 'defname':
            defname_ = child_.text
            defname_ = self.gds_validate_string(defname_, node, 'defname')
            self.defname = defname_
        elif nodeName_ == 'array':
            array_ = child_.text
            array_ = self.gds_validate_string(array_, node, 'array')
            self.array = array_
        elif nodeName_ == 'defval':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.defval = obj_
            obj_.original_tagname_ = 'defval'
        elif nodeName_ == 'typeconstraint':
            obj_ = linkedTextType.factory()
            obj_.build(child_)
            self.typeconstraint = obj_
            obj_.original_tagname_ = 'typeconstraint'
        elif nodeName_ == 'briefdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.briefdescription = obj_
            obj_.original_tagname_ = 'briefdescription'
# end class paramType


class declname(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, declname)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if declname.subclass:
            return declname.subclass(*args_, **kwargs_)
        else:
            return declname(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='declname', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('declname')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='declname')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='declname', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='declname'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='declname', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class declname


class defname(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, defname)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if defname.subclass:
            return defname.subclass(*args_, **kwargs_)
        else:
            return defname(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='defname', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('defname')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='defname')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='defname', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='defname'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='defname', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class defname


class array(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, array)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if array.subclass:
            return array.subclass(*args_, **kwargs_)
        else:
            return array(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='array', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('array')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='array')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='array', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='array'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='array', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class array


class linkedTextType(GeneratedsSuper):
    node_type = "linkedtext"

    subclass = None
    superclass = None
    def __init__(self, ref=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, linkedTextType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if linkedTextType.subclass:
            return linkedTextType.subclass(*args_, **kwargs_)
        else:
            return linkedTextType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ref or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='linkedTextType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('linkedTextType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='linkedTextType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='linkedTextType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='linkedTextType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='linkedTextType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ref':
            obj_ = refTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class linkedTextType


class graphType(GeneratedsSuper):
    node_type = "graph"

    subclass = None
    superclass = None
    def __init__(self, node=None):
        self.original_tagname_ = None
        if node is None:
            self.node = []
        else:
            self.node = node
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, graphType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if graphType.subclass:
            return graphType.subclass(*args_, **kwargs_)
        else:
            return graphType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_node(self): return self.node
    def set_node(self, node): self.node = node
    def add_node(self, value): self.node.append(value)
    def insert_node_at(self, index, value): self.node.insert(index, value)
    def replace_node_at(self, index, value): self.node[index] = value
    def hasContent_(self):
        if (
            self.node
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='graphType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('graphType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='graphType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='graphType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='graphType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='graphType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for node_ in self.node:
            node_.export(outfile, level, namespace_, name_='node', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'node':
            obj_ = nodeType.factory()
            obj_.build(child_)
            self.node.append(obj_)
            obj_.original_tagname_ = 'node'
# end class graphType


class nodeType(GeneratedsSuper):
    node_type = "node"

    subclass = None
    superclass = None
    def __init__(self, id=None, label=None, link=None, childnode=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.label = label
        self.link = link
        if childnode is None:
            self.childnode = []
        else:
            self.childnode = childnode
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, nodeType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if nodeType.subclass:
            return nodeType.subclass(*args_, **kwargs_)
        else:
            return nodeType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_label(self): return self.label
    def set_label(self, label): self.label = label
    def get_link(self): return self.link
    def set_link(self, link): self.link = link
    def get_childnode(self): return self.childnode
    def set_childnode(self, childnode): self.childnode = childnode
    def add_childnode(self, value): self.childnode.append(value)
    def insert_childnode_at(self, index, value): self.childnode.insert(index, value)
    def replace_childnode_at(self, index, value): self.childnode[index] = value
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def hasContent_(self):
        if (
            self.label is not None or
            self.link is not None or
            self.childnode
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='nodeType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('nodeType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='nodeType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='nodeType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='nodeType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='nodeType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.label is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<label>%s</label>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.label), input_name='label')), eol_))
        if self.link is not None:
            self.link.export(outfile, level, namespace_, name_='link', pretty_print=pretty_print)
        for childnode_ in self.childnode:
            childnode_.export(outfile, level, namespace_, name_='childnode', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'label':
            label_ = child_.text
            label_ = self.gds_validate_string(label_, node, 'label')
            self.label = label_
        elif nodeName_ == 'link':
            obj_ = linkType.factory()
            obj_.build(child_)
            self.link = obj_
            obj_.original_tagname_ = 'link'
        elif nodeName_ == 'childnode':
            obj_ = childnodeType.factory()
            obj_.build(child_)
            self.childnode.append(obj_)
            obj_.original_tagname_ = 'childnode'
# end class nodeType


class label(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, label)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if label.subclass:
            return label.subclass(*args_, **kwargs_)
        else:
            return label(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='label', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('label')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='label')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='label', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='label'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='label', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class label


class childnodeType(GeneratedsSuper):
    node_type = "childnode"

    subclass = None
    superclass = None
    def __init__(self, refid=None, relation=None, edgelabel=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.relation = _cast(None, relation)
        if edgelabel is None:
            self.edgelabel = []
        else:
            self.edgelabel = edgelabel
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, childnodeType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if childnodeType.subclass:
            return childnodeType.subclass(*args_, **kwargs_)
        else:
            return childnodeType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_edgelabel(self): return self.edgelabel
    def set_edgelabel(self, edgelabel): self.edgelabel = edgelabel
    def add_edgelabel(self, value): self.edgelabel.append(value)
    def insert_edgelabel_at(self, index, value): self.edgelabel.insert(index, value)
    def replace_edgelabel_at(self, index, value): self.edgelabel[index] = value
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_relation(self): return self.relation
    def set_relation(self, relation): self.relation = relation
    def validate_DoxGraphRelation(self, value):
        # Validate type DoxGraphRelation, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['include', 'usage', 'template-instance', 'public-inheritance', 'protected-inheritance', 'private-inheritance', 'type-constraint']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxGraphRelation' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.edgelabel
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='childnodeType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('childnodeType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='childnodeType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='childnodeType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='childnodeType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.relation is not None and 'relation' not in already_processed:
            already_processed.add('relation')
            outfile.write(' relation=%s' % (quote_attrib(self.relation), ))
    def exportChildren(self, outfile, level, namespace_='', name_='childnodeType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for edgelabel_ in self.edgelabel:
            showIndent(outfile, level, pretty_print)
            outfile.write('<edgelabel>%s</edgelabel>%s' % (self.gds_encode(self.gds_format_string(quote_xml(edgelabel_), input_name='edgelabel')), eol_))
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('relation', node)
        if value is not None and 'relation' not in already_processed:
            already_processed.add('relation')
            self.relation = value
            self.validate_DoxGraphRelation(self.relation)    # validate type DoxGraphRelation
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'edgelabel':
            edgelabel_ = child_.text
            edgelabel_ = self.gds_validate_string(edgelabel_, node, 'edgelabel')
            self.edgelabel.append(edgelabel_)
# end class childnodeType


class edgelabel(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, edgelabel)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if edgelabel.subclass:
            return edgelabel.subclass(*args_, **kwargs_)
        else:
            return edgelabel(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='edgelabel', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('edgelabel')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='edgelabel')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='edgelabel', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='edgelabel'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='edgelabel', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class edgelabel


class linkType(GeneratedsSuper):
    node_type = "link"

    subclass = None
    superclass = None
    def __init__(self, refid=None, external=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.external = _cast(None, external)
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, linkType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if linkType.subclass:
            return linkType.subclass(*args_, **kwargs_)
        else:
            return linkType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_external(self): return self.external
    def set_external(self, external): self.external = external
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='linkType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('linkType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='linkType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='linkType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='linkType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.external is not None and 'external' not in already_processed:
            already_processed.add('external')
            outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='linkType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('external', node)
        if value is not None and 'external' not in already_processed:
            already_processed.add('external')
            self.external = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class linkType


class listingType(GeneratedsSuper):
    node_type = "listing"

    subclass = None
    superclass = None
    def __init__(self, codeline=None):
        self.original_tagname_ = None
        if codeline is None:
            self.codeline = []
        else:
            self.codeline = codeline
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, listingType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if listingType.subclass:
            return listingType.subclass(*args_, **kwargs_)
        else:
            return listingType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_codeline(self): return self.codeline
    def set_codeline(self, codeline): self.codeline = codeline
    def add_codeline(self, value): self.codeline.append(value)
    def insert_codeline_at(self, index, value): self.codeline.insert(index, value)
    def replace_codeline_at(self, index, value): self.codeline[index] = value
    def hasContent_(self):
        if (
            self.codeline
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='listingType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('listingType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='listingType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='listingType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='listingType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='listingType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for codeline_ in self.codeline:
            codeline_.export(outfile, level, namespace_, name_='codeline', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'codeline':
            obj_ = codelineType.factory()
            obj_.build(child_)
            self.codeline.append(obj_)
            obj_.original_tagname_ = 'codeline'
# end class listingType


class codelineType(GeneratedsSuper):
    node_type = "codeline"

    subclass = None
    superclass = None
    def __init__(self, lineno=None, refid=None, refkind=None, external=None, highlight=None):
        self.original_tagname_ = None
        self.lineno = _cast(int, lineno)
        self.refid = _cast(None, refid)
        self.refkind = _cast(None, refkind)
        self.external = _cast(None, external)
        if highlight is None:
            self.highlight = []
        else:
            self.highlight = highlight
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, codelineType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if codelineType.subclass:
            return codelineType.subclass(*args_, **kwargs_)
        else:
            return codelineType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_highlight(self): return self.highlight
    def set_highlight(self, highlight): self.highlight = highlight
    def add_highlight(self, value): self.highlight.append(value)
    def insert_highlight_at(self, index, value): self.highlight.insert(index, value)
    def replace_highlight_at(self, index, value): self.highlight[index] = value
    def get_lineno(self): return self.lineno
    def set_lineno(self, lineno): self.lineno = lineno
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_refkind(self): return self.refkind
    def set_refkind(self, refkind): self.refkind = refkind
    def get_external(self): return self.external
    def set_external(self, external): self.external = external
    def validate_DoxRefKind(self, value):
        # Validate type DoxRefKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['compound', 'member']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxRefKind' % {"value" : value.encode("utf-8")} )
    def validate_DoxBool(self, value):
        # Validate type DoxBool, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['yes', 'no']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxBool' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.highlight
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='codelineType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('codelineType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='codelineType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='codelineType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='codelineType'):
        if self.lineno is not None and 'lineno' not in already_processed:
            already_processed.add('lineno')
            outfile.write(' lineno="%s"' % self.gds_format_integer(self.lineno, input_name='lineno'))
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.refkind is not None and 'refkind' not in already_processed:
            already_processed.add('refkind')
            outfile.write(' refkind=%s' % (quote_attrib(self.refkind), ))
        if self.external is not None and 'external' not in already_processed:
            already_processed.add('external')
            outfile.write(' external=%s' % (quote_attrib(self.external), ))
    def exportChildren(self, outfile, level, namespace_='', name_='codelineType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for highlight_ in self.highlight:
            highlight_.export(outfile, level, namespace_, name_='highlight', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('lineno', node)
        if value is not None and 'lineno' not in already_processed:
            already_processed.add('lineno')
            try:
                self.lineno = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('refkind', node)
        if value is not None and 'refkind' not in already_processed:
            already_processed.add('refkind')
            self.refkind = value
            self.validate_DoxRefKind(self.refkind)    # validate type DoxRefKind
        value = find_attr_value_('external', node)
        if value is not None and 'external' not in already_processed:
            already_processed.add('external')
            self.external = value
            self.validate_DoxBool(self.external)    # validate type DoxBool
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'highlight':
            obj_ = highlightType.factory()
            obj_.build(child_)
            self.highlight.append(obj_)
            obj_.original_tagname_ = 'highlight'
# end class codelineType


class highlightType(GeneratedsSuper):
    node_type = "highlight"

    subclass = None
    superclass = None
    def __init__(self, class_=None, sp=None, ref=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.class_ = _cast(None, class_)
        if sp is None:
            self.sp = []
        else:
            self.sp = sp
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, highlightType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if highlightType.subclass:
            return highlightType.subclass(*args_, **kwargs_)
        else:
            return highlightType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_sp(self): return self.sp
    def set_sp(self, sp): self.sp = sp
    def add_sp(self, value): self.sp.append(value)
    def insert_sp_at(self, index, value): self.sp.insert(index, value)
    def replace_sp_at(self, index, value): self.sp[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_class(self): return self.class_
    def set_class(self, class_): self.class_ = class_
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxHighlightClass(self, value):
        # Validate type DoxHighlightClass, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['comment', 'normal', 'preprocessor', 'keyword', 'keywordtype', 'keywordflow', 'stringliteral', 'charliteral']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxHighlightClass' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.sp or
            self.ref or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='highlightType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('highlightType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='highlightType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='highlightType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='highlightType'):
        if self.class_ is not None and 'class_' not in already_processed:
            already_processed.add('class_')
            outfile.write(' class=%s' % (quote_attrib(self.class_), ))
    def exportChildren(self, outfile, level, namespace_='', name_='highlightType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for sp_ in self.sp:
            showIndent(outfile, level, pretty_print)
            outfile.write('<sp>%s</sp>%s' % (self.gds_encode(self.gds_format_string(quote_xml(sp_), input_name='sp')), eol_))
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('class', node)
        if value is not None and 'class' not in already_processed:
            already_processed.add('class')
            self.class_ = value
            self.validate_DoxHighlightClass(self.class_)    # validate type DoxHighlightClass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'sp' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'sp', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'ref':
            obj_ = refTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class highlightType


class sp(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, sp)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if sp.subclass:
            return sp.subclass(*args_, **kwargs_)
        else:
            return sp(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='sp', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('sp')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='sp')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='sp', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='sp'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='sp', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class sp


class referenceType(GeneratedsSuper):
    node_type = "reference"

    subclass = None
    superclass = None
    def __init__(self, refid=None, compoundref=None, startline=None, endline=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.compoundref = _cast(None, compoundref)
        self.startline = _cast(int, startline)
        self.endline = _cast(int, endline)
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, referenceType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if referenceType.subclass:
            return referenceType.subclass(*args_, **kwargs_)
        else:
            return referenceType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_compoundref(self): return self.compoundref
    def set_compoundref(self, compoundref): self.compoundref = compoundref
    def get_startline(self): return self.startline
    def set_startline(self, startline): self.startline = startline
    def get_endline(self): return self.endline
    def set_endline(self, endline): self.endline = endline
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='referenceType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('referenceType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='referenceType')
        outfile.write('>')
        self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print)
        outfile.write(self.convert_unicode(self.valueOf_))
        outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='referenceType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.compoundref is not None and 'compoundref' not in already_processed:
            already_processed.add('compoundref')
            outfile.write(' compoundref=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.compoundref), input_name='compoundref')), ))
        if self.startline is not None and 'startline' not in already_processed:
            already_processed.add('startline')
            outfile.write(' startline="%s"' % self.gds_format_integer(self.startline, input_name='startline'))
        if self.endline is not None and 'endline' not in already_processed:
            already_processed.add('endline')
            outfile.write(' endline="%s"' % self.gds_format_integer(self.endline, input_name='endline'))
    def exportChildren(self, outfile, level, namespace_='', name_='referenceType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('compoundref', node)
        if value is not None and 'compoundref' not in already_processed:
            already_processed.add('compoundref')
            self.compoundref = value
        value = find_attr_value_('startline', node)
        if value is not None and 'startline' not in already_processed:
            already_processed.add('startline')
            try:
                self.startline = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('endline', node)
        if value is not None and 'endline' not in already_processed:
            already_processed.add('endline')
            try:
                self.endline = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
        pass
# end class referenceType


class locationType(GeneratedsSuper):
    node_type = "location"

    subclass = None
    superclass = None
    def __init__(self, file=None, line=None, column=None, bodyfile=None, bodystart=None, bodyend=None):
        self.original_tagname_ = None
        self.file = _cast(None, file)
        self.line = _cast(int, line)
        self.column = _cast(int, column)
        self.bodyfile = _cast(None, bodyfile)
        self.bodystart = _cast(int, bodystart)
        self.bodyend = _cast(int, bodyend)
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, locationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if locationType.subclass:
            return locationType.subclass(*args_, **kwargs_)
        else:
            return locationType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_file(self): return self.file
    def set_file(self, file): self.file = file
    def get_line(self): return self.line
    def set_line(self, line): self.line = line
    def get_column(self): return self.column
    def set_column(self, column): self.column = column
    def get_bodyfile(self): return self.bodyfile
    def set_bodyfile(self, bodyfile): self.bodyfile = bodyfile
    def get_bodystart(self): return self.bodystart
    def set_bodystart(self, bodystart): self.bodystart = bodystart
    def get_bodyend(self): return self.bodyend
    def set_bodyend(self, bodyend): self.bodyend = bodyend
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='locationType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('locationType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='locationType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='locationType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='locationType'):
        if self.file is not None and 'file' not in already_processed:
            already_processed.add('file')
            outfile.write(' file=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.file), input_name='file')), ))
        if self.line is not None and 'line' not in already_processed:
            already_processed.add('line')
            outfile.write(' line="%s"' % self.gds_format_integer(self.line, input_name='line'))
        if self.column is not None and 'column' not in already_processed:
            already_processed.add('column')
            outfile.write(' column="%s"' % self.gds_format_integer(self.column, input_name='column'))
        if self.bodyfile is not None and 'bodyfile' not in already_processed:
            already_processed.add('bodyfile')
            outfile.write(' bodyfile=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.bodyfile), input_name='bodyfile')), ))
        if self.bodystart is not None and 'bodystart' not in already_processed:
            already_processed.add('bodystart')
            outfile.write(' bodystart="%s"' % self.gds_format_integer(self.bodystart, input_name='bodystart'))
        if self.bodyend is not None and 'bodyend' not in already_processed:
            already_processed.add('bodyend')
            outfile.write(' bodyend="%s"' % self.gds_format_integer(self.bodyend, input_name='bodyend'))
    def exportChildren(self, outfile, level, namespace_='', name_='locationType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('file', node)
        if value is not None and 'file' not in already_processed:
            already_processed.add('file')
            self.file = value
        value = find_attr_value_('line', node)
        if value is not None and 'line' not in already_processed:
            already_processed.add('line')
            try:
                self.line = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('column', node)
        if value is not None and 'column' not in already_processed:
            already_processed.add('column')
            try:
                self.column = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('bodyfile', node)
        if value is not None and 'bodyfile' not in already_processed:
            already_processed.add('bodyfile')
            self.bodyfile = value
        value = find_attr_value_('bodystart', node)
        if value is not None and 'bodystart' not in already_processed:
            already_processed.add('bodystart')
            try:
                self.bodystart = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('bodyend', node)
        if value is not None and 'bodyend' not in already_processed:
            already_processed.add('bodyend')
            try:
                self.bodyend = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class locationType


class docSect1Type(GeneratedsSuper):
    node_type = "docsect1"

    subclass = None
    superclass = None
    def __init__(self, id=None, title=None, para=None, sect2=None, internal=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect2 is None:
            self.sect2 = []
        else:
            self.sect2 = sect2
        self.internal = internal
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docSect1Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docSect1Type.subclass:
            return docSect1Type.subclass(*args_, **kwargs_)
        else:
            return docSect1Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect2(self): return self.sect2
    def set_sect2(self, sect2): self.sect2 = sect2
    def add_sect2(self, value): self.sect2.append(value)
    def insert_sect2_at(self, index, value): self.sect2.insert(index, value)
    def replace_sect2_at(self, index, value): self.sect2[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.title is not None or
            self.para or
            self.sect2 or
            self.internal is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docSect1Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect1Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docSect1Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docSect1Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docSect1Type'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docSect1Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect2_ in self.sect2:
            sect2_.export(outfile, level, namespace_, name_='sect2', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'title', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect2':
            obj_ = docSect2Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect2'):
              self.add_sect2(obj_.value)
            elif hasattr(self, 'set_sect2'):
              self.set_sect2(obj_.value)
        elif nodeName_ == 'internal':
            obj_ = docInternalS1Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'internal', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_internal'):
              self.add_internal(obj_.value)
            elif hasattr(self, 'set_internal'):
              self.set_internal(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docSect1Type


class docSect2Type(GeneratedsSuper):
    node_type = "docsect2"

    subclass = None
    superclass = None
    def __init__(self, id=None, title=None, para=None, sect3=None, internal=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect3 is None:
            self.sect3 = []
        else:
            self.sect3 = sect3
        self.internal = internal
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docSect2Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docSect2Type.subclass:
            return docSect2Type.subclass(*args_, **kwargs_)
        else:
            return docSect2Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect3(self): return self.sect3
    def set_sect3(self, sect3): self.sect3 = sect3
    def add_sect3(self, value): self.sect3.append(value)
    def insert_sect3_at(self, index, value): self.sect3.insert(index, value)
    def replace_sect3_at(self, index, value): self.sect3[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.title is not None or
            self.para or
            self.sect3 or
            self.internal is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docSect2Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect2Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docSect2Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docSect2Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docSect2Type'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docSect2Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect3_ in self.sect3:
            sect3_.export(outfile, level, namespace_, name_='sect3', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'title', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect3':
            obj_ = docSect3Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect3'):
              self.add_sect3(obj_.value)
            elif hasattr(self, 'set_sect3'):
              self.set_sect3(obj_.value)
        elif nodeName_ == 'internal':
            obj_ = docInternalS2Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'internal', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_internal'):
              self.add_internal(obj_.value)
            elif hasattr(self, 'set_internal'):
              self.set_internal(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docSect2Type


class docSect3Type(GeneratedsSuper):
    node_type = "docsect3"

    subclass = None
    superclass = None
    def __init__(self, id=None, title=None, para=None, sect4=None, internal=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect4 is None:
            self.sect4 = []
        else:
            self.sect4 = sect4
        self.internal = internal
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docSect3Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docSect3Type.subclass:
            return docSect3Type.subclass(*args_, **kwargs_)
        else:
            return docSect3Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect4(self): return self.sect4
    def set_sect4(self, sect4): self.sect4 = sect4
    def add_sect4(self, value): self.sect4.append(value)
    def insert_sect4_at(self, index, value): self.sect4.insert(index, value)
    def replace_sect4_at(self, index, value): self.sect4[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.title is not None or
            self.para or
            self.sect4 or
            self.internal is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docSect3Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect3Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docSect3Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docSect3Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docSect3Type'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docSect3Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect4_ in self.sect4:
            sect4_.export(outfile, level, namespace_, name_='sect4', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'title', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect4':
            obj_ = docSect4Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect4'):
              self.add_sect4(obj_.value)
            elif hasattr(self, 'set_sect4'):
              self.set_sect4(obj_.value)
        elif nodeName_ == 'internal':
            obj_ = docInternalS3Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'internal', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_internal'):
              self.add_internal(obj_.value)
            elif hasattr(self, 'set_internal'):
              self.set_internal(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docSect3Type


class docSect4Type(GeneratedsSuper):
    node_type = "docsect4"

    subclass = None
    superclass = None
    def __init__(self, id=None, title=None, para=None, internal=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
        self.internal = internal
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docSect4Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docSect4Type.subclass:
            return docSect4Type.subclass(*args_, **kwargs_)
        else:
            return docSect4Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.title is not None or
            self.para or
            self.internal is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docSect4Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSect4Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docSect4Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docSect4Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docSect4Type'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docSect4Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<title>%s</title>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.title), input_name='title')), eol_))
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'title', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'internal':
            obj_ = docInternalS4Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'internal', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_internal'):
              self.add_internal(obj_.value)
            elif hasattr(self, 'set_internal'):
              self.set_internal(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docSect4Type


class docInternalType(GeneratedsSuper):
    node_type = "docinternal"

    subclass = None
    superclass = None
    def __init__(self, para=None, sect1=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect1 is None:
            self.sect1 = []
        else:
            self.sect1 = sect1
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docInternalType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docInternalType.subclass:
            return docInternalType.subclass(*args_, **kwargs_)
        else:
            return docInternalType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect1(self): return self.sect1
    def set_sect1(self, sect1): self.sect1 = sect1
    def add_sect1(self, value): self.sect1.append(value)
    def insert_sect1_at(self, index, value): self.sect1.insert(index, value)
    def replace_sect1_at(self, index, value): self.sect1[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.para or
            self.sect1 or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docInternalType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docInternalType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docInternalType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docInternalType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docInternalType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect1_ in self.sect1:
            sect1_.export(outfile, level, namespace_, name_='sect1', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect1':
            obj_ = docSect1Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect1'):
              self.add_sect1(obj_.value)
            elif hasattr(self, 'set_sect1'):
              self.set_sect1(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docInternalType


class docInternalS1Type(GeneratedsSuper):
    node_type = "docinternals1"

    subclass = None
    superclass = None
    def __init__(self, para=None, sect2=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect2 is None:
            self.sect2 = []
        else:
            self.sect2 = sect2
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docInternalS1Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docInternalS1Type.subclass:
            return docInternalS1Type.subclass(*args_, **kwargs_)
        else:
            return docInternalS1Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect2(self): return self.sect2
    def set_sect2(self, sect2): self.sect2 = sect2
    def add_sect2(self, value): self.sect2.append(value)
    def insert_sect2_at(self, index, value): self.sect2.insert(index, value)
    def replace_sect2_at(self, index, value): self.sect2[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.para or
            self.sect2 or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docInternalS1Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS1Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docInternalS1Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docInternalS1Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docInternalS1Type'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docInternalS1Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect2_ in self.sect2:
            sect2_.export(outfile, level, namespace_, name_='sect2', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect2':
            obj_ = docSect2Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect2'):
              self.add_sect2(obj_.value)
            elif hasattr(self, 'set_sect2'):
              self.set_sect2(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docInternalS1Type


class docInternalS2Type(GeneratedsSuper):
    node_type = "docinternals2"

    subclass = None
    superclass = None
    def __init__(self, para=None, sect3=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect3 is None:
            self.sect3 = []
        else:
            self.sect3 = sect3
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docInternalS2Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docInternalS2Type.subclass:
            return docInternalS2Type.subclass(*args_, **kwargs_)
        else:
            return docInternalS2Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect3(self): return self.sect3
    def set_sect3(self, sect3): self.sect3 = sect3
    def add_sect3(self, value): self.sect3.append(value)
    def insert_sect3_at(self, index, value): self.sect3.insert(index, value)
    def replace_sect3_at(self, index, value): self.sect3[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.para or
            self.sect3 or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docInternalS2Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS2Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docInternalS2Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docInternalS2Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docInternalS2Type'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docInternalS2Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect3_ in self.sect3:
            sect3_.export(outfile, level, namespace_, name_='sect3', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect3':
            obj_ = docSect3Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect3'):
              self.add_sect3(obj_.value)
            elif hasattr(self, 'set_sect3'):
              self.set_sect3(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docInternalS2Type


class docInternalS3Type(GeneratedsSuper):
    node_type = "docinternals3"

    subclass = None
    superclass = None
    def __init__(self, para=None, sect3=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect3 is None:
            self.sect3 = []
        else:
            self.sect3 = sect3
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docInternalS3Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docInternalS3Type.subclass:
            return docInternalS3Type.subclass(*args_, **kwargs_)
        else:
            return docInternalS3Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect3(self): return self.sect3
    def set_sect3(self, sect3): self.sect3 = sect3
    def add_sect3(self, value): self.sect3.append(value)
    def insert_sect3_at(self, index, value): self.sect3.insert(index, value)
    def replace_sect3_at(self, index, value): self.sect3[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.para or
            self.sect3 or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docInternalS3Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS3Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docInternalS3Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docInternalS3Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docInternalS3Type'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docInternalS3Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect3_ in self.sect3:
            sect3_.export(outfile, level, namespace_, name_='sect3', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'sect3':
            obj_ = docSect4Type.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect3'):
              self.add_sect3(obj_.value)
            elif hasattr(self, 'set_sect3'):
              self.set_sect3(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docInternalS3Type


class docInternalS4Type(GeneratedsSuper):
    node_type = "docinternals4"

    subclass = None
    superclass = None
    def __init__(self, para=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docInternalS4Type)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docInternalS4Type.subclass:
            return docInternalS4Type.subclass(*args_, **kwargs_)
        else:
            return docInternalS4Type(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.para or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docInternalS4Type', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docInternalS4Type')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docInternalS4Type')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docInternalS4Type', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docInternalS4Type'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docInternalS4Type', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docInternalS4Type


class docTitleType(GeneratedsSuper):
    node_type = "doctitle"

    subclass = None
    superclass = None
    def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docTitleType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docTitleType.subclass:
            return docTitleType.subclass(*args_, **kwargs_)
        else:
            return docTitleType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docTitleType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTitleType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docTitleType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docTitleType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docTitleType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docTitleType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docTitleType


class docParaType(GeneratedsSuper):
    node_type = "docpara"

    subclass = None
    superclass = None
    def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, linebreak=None, hruler=None, preformatted=None, programlisting=None, verbatim=None, indexentry=None, orderedlist=None, itemizedlist=None, simplesect=None, title=None, variablelist=None, table=None, heading=None, image=None, dotfile=None, mscfile=None, diafile=None, toclist=None, language=None, parameterlist=None, xrefsect=None, copydoc=None, blockquote=None, parblock=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        if linebreak is None:
            self.linebreak = []
        else:
            self.linebreak = linebreak
        if hruler is None:
            self.hruler = []
        else:
            self.hruler = hruler
        if preformatted is None:
            self.preformatted = []
        else:
            self.preformatted = preformatted
        if programlisting is None:
            self.programlisting = []
        else:
            self.programlisting = programlisting
        if verbatim is None:
            self.verbatim = []
        else:
            self.verbatim = verbatim
        if indexentry is None:
            self.indexentry = []
        else:
            self.indexentry = indexentry
        if orderedlist is None:
            self.orderedlist = []
        else:
            self.orderedlist = orderedlist
        if itemizedlist is None:
            self.itemizedlist = []
        else:
            self.itemizedlist = itemizedlist
        if simplesect is None:
            self.simplesect = []
        else:
            self.simplesect = simplesect
        if title is None:
            self.title = []
        else:
            self.title = title
        if variablelist is None:
            self.variablelist = []
        else:
            self.variablelist = variablelist
        if table is None:
            self.table = []
        else:
            self.table = table
        if heading is None:
            self.heading = []
        else:
            self.heading = heading
        if image is None:
            self.image = []
        else:
            self.image = image
        if dotfile is None:
            self.dotfile = []
        else:
            self.dotfile = dotfile
        if mscfile is None:
            self.mscfile = []
        else:
            self.mscfile = mscfile
        if diafile is None:
            self.diafile = []
        else:
            self.diafile = diafile
        if toclist is None:
            self.toclist = []
        else:
            self.toclist = toclist
        if language is None:
            self.language = []
        else:
            self.language = language
        if parameterlist is None:
            self.parameterlist = []
        else:
            self.parameterlist = parameterlist
        if xrefsect is None:
            self.xrefsect = []
        else:
            self.xrefsect = xrefsect
        if copydoc is None:
            self.copydoc = []
        else:
            self.copydoc = copydoc
        if blockquote is None:
            self.blockquote = []
        else:
            self.blockquote = blockquote
        if parblock is None:
            self.parblock = []
        else:
            self.parblock = parblock
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParaType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParaType.subclass:
            return docParaType.subclass(*args_, **kwargs_)
        else:
            return docParaType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_linebreak(self): return self.linebreak
    def set_linebreak(self, linebreak): self.linebreak = linebreak
    def add_linebreak(self, value): self.linebreak.append(value)
    def insert_linebreak_at(self, index, value): self.linebreak.insert(index, value)
    def replace_linebreak_at(self, index, value): self.linebreak[index] = value
    def get_hruler(self): return self.hruler
    def set_hruler(self, hruler): self.hruler = hruler
    def add_hruler(self, value): self.hruler.append(value)
    def insert_hruler_at(self, index, value): self.hruler.insert(index, value)
    def replace_hruler_at(self, index, value): self.hruler[index] = value
    def get_preformatted(self): return self.preformatted
    def set_preformatted(self, preformatted): self.preformatted = preformatted
    def add_preformatted(self, value): self.preformatted.append(value)
    def insert_preformatted_at(self, index, value): self.preformatted.insert(index, value)
    def replace_preformatted_at(self, index, value): self.preformatted[index] = value
    def get_programlisting(self): return self.programlisting
    def set_programlisting(self, programlisting): self.programlisting = programlisting
    def add_programlisting(self, value): self.programlisting.append(value)
    def insert_programlisting_at(self, index, value): self.programlisting.insert(index, value)
    def replace_programlisting_at(self, index, value): self.programlisting[index] = value
    def get_verbatim(self): return self.verbatim
    def set_verbatim(self, verbatim): self.verbatim = verbatim
    def add_verbatim(self, value): self.verbatim.append(value)
    def insert_verbatim_at(self, index, value): self.verbatim.insert(index, value)
    def replace_verbatim_at(self, index, value): self.verbatim[index] = value
    def get_indexentry(self): return self.indexentry
    def set_indexentry(self, indexentry): self.indexentry = indexentry
    def add_indexentry(self, value): self.indexentry.append(value)
    def insert_indexentry_at(self, index, value): self.indexentry.insert(index, value)
    def replace_indexentry_at(self, index, value): self.indexentry[index] = value
    def get_orderedlist(self): return self.orderedlist
    def set_orderedlist(self, orderedlist): self.orderedlist = orderedlist
    def add_orderedlist(self, value): self.orderedlist.append(value)
    def insert_orderedlist_at(self, index, value): self.orderedlist.insert(index, value)
    def replace_orderedlist_at(self, index, value): self.orderedlist[index] = value
    def get_itemizedlist(self): return self.itemizedlist
    def set_itemizedlist(self, itemizedlist): self.itemizedlist = itemizedlist
    def add_itemizedlist(self, value): self.itemizedlist.append(value)
    def insert_itemizedlist_at(self, index, value): self.itemizedlist.insert(index, value)
    def replace_itemizedlist_at(self, index, value): self.itemizedlist[index] = value
    def get_simplesect(self): return self.simplesect
    def set_simplesect(self, simplesect): self.simplesect = simplesect
    def add_simplesect(self, value): self.simplesect.append(value)
    def insert_simplesect_at(self, index, value): self.simplesect.insert(index, value)
    def replace_simplesect_at(self, index, value): self.simplesect[index] = value
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def add_title(self, value): self.title.append(value)
    def insert_title_at(self, index, value): self.title.insert(index, value)
    def replace_title_at(self, index, value): self.title[index] = value
    def get_variablelist(self): return self.variablelist
    def set_variablelist(self, variablelist): self.variablelist = variablelist
    def add_variablelist(self, value): self.variablelist.append(value)
    def insert_variablelist_at(self, index, value): self.variablelist.insert(index, value)
    def replace_variablelist_at(self, index, value): self.variablelist[index] = value
    def get_table(self): return self.table
    def set_table(self, table): self.table = table
    def add_table(self, value): self.table.append(value)
    def insert_table_at(self, index, value): self.table.insert(index, value)
    def replace_table_at(self, index, value): self.table[index] = value
    def get_heading(self): return self.heading
    def set_heading(self, heading): self.heading = heading
    def add_heading(self, value): self.heading.append(value)
    def insert_heading_at(self, index, value): self.heading.insert(index, value)
    def replace_heading_at(self, index, value): self.heading[index] = value
    def get_image(self): return self.image
    def set_image(self, image): self.image = image
    def add_image(self, value): self.image.append(value)
    def insert_image_at(self, index, value): self.image.insert(index, value)
    def replace_image_at(self, index, value): self.image[index] = value
    def get_dotfile(self): return self.dotfile
    def set_dotfile(self, dotfile): self.dotfile = dotfile
    def add_dotfile(self, value): self.dotfile.append(value)
    def insert_dotfile_at(self, index, value): self.dotfile.insert(index, value)
    def replace_dotfile_at(self, index, value): self.dotfile[index] = value
    def get_mscfile(self): return self.mscfile
    def set_mscfile(self, mscfile): self.mscfile = mscfile
    def add_mscfile(self, value): self.mscfile.append(value)
    def insert_mscfile_at(self, index, value): self.mscfile.insert(index, value)
    def replace_mscfile_at(self, index, value): self.mscfile[index] = value
    def get_diafile(self): return self.diafile
    def set_diafile(self, diafile): self.diafile = diafile
    def add_diafile(self, value): self.diafile.append(value)
    def insert_diafile_at(self, index, value): self.diafile.insert(index, value)
    def replace_diafile_at(self, index, value): self.diafile[index] = value
    def get_toclist(self): return self.toclist
    def set_toclist(self, toclist): self.toclist = toclist
    def add_toclist(self, value): self.toclist.append(value)
    def insert_toclist_at(self, index, value): self.toclist.insert(index, value)
    def replace_toclist_at(self, index, value): self.toclist[index] = value
    def get_language(self): return self.language
    def set_language(self, language): self.language = language
    def add_language(self, value): self.language.append(value)
    def insert_language_at(self, index, value): self.language.insert(index, value)
    def replace_language_at(self, index, value): self.language[index] = value
    def get_parameterlist(self): return self.parameterlist
    def set_parameterlist(self, parameterlist): self.parameterlist = parameterlist
    def add_parameterlist(self, value): self.parameterlist.append(value)
    def insert_parameterlist_at(self, index, value): self.parameterlist.insert(index, value)
    def replace_parameterlist_at(self, index, value): self.parameterlist[index] = value
    def get_xrefsect(self): return self.xrefsect
    def set_xrefsect(self, xrefsect): self.xrefsect = xrefsect
    def add_xrefsect(self, value): self.xrefsect.append(value)
    def insert_xrefsect_at(self, index, value): self.xrefsect.insert(index, value)
    def replace_xrefsect_at(self, index, value): self.xrefsect[index] = value
    def get_copydoc(self): return self.copydoc
    def set_copydoc(self, copydoc): self.copydoc = copydoc
    def add_copydoc(self, value): self.copydoc.append(value)
    def insert_copydoc_at(self, index, value): self.copydoc.insert(index, value)
    def replace_copydoc_at(self, index, value): self.copydoc[index] = value
    def get_blockquote(self): return self.blockquote
    def set_blockquote(self, blockquote): self.blockquote = blockquote
    def add_blockquote(self, value): self.blockquote.append(value)
    def insert_blockquote_at(self, index, value): self.blockquote.insert(index, value)
    def replace_blockquote_at(self, index, value): self.blockquote[index] = value
    def get_parblock(self): return self.parblock
    def set_parblock(self, parblock): self.parblock = parblock
    def add_parblock(self, value): self.parblock.append(value)
    def insert_parblock_at(self, index, value): self.parblock.insert(index, value)
    def replace_parblock_at(self, index, value): self.parblock[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            self.linebreak or
            self.hruler or
            self.preformatted or
            self.programlisting or
            self.verbatim or
            self.indexentry or
            self.orderedlist or
            self.itemizedlist or
            self.simplesect or
            self.title or
            self.variablelist or
            self.table or
            self.heading or
            self.image or
            self.dotfile or
            self.mscfile or
            self.diafile or
            self.toclist or
            self.language or
            self.parameterlist or
            self.xrefsect or
            self.copydoc or
            self.blockquote or
            self.parblock or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParaType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParaType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParaType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParaType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParaType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docParaType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
        for linebreak_ in self.linebreak:
            linebreak_.export(outfile, level, namespace_, name_='linebreak', pretty_print=pretty_print)
        for hruler_ in self.hruler:
            hruler_.export(outfile, level, namespace_, name_='hruler', pretty_print=pretty_print)
        for preformatted_ in self.preformatted:
            preformatted_.export(outfile, level, namespace_, name_='preformatted', pretty_print=pretty_print)
        for programlisting_ in self.programlisting:
            programlisting_.export(outfile, level, namespace_, name_='programlisting', pretty_print=pretty_print)
        for verbatim_ in self.verbatim:
            showIndent(outfile, level, pretty_print)
            outfile.write('<verbatim>%s</verbatim>%s' % (self.gds_encode(self.gds_format_string(quote_xml(verbatim_), input_name='verbatim')), eol_))
        for indexentry_ in self.indexentry:
            indexentry_.export(outfile, level, namespace_, name_='indexentry', pretty_print=pretty_print)
        for orderedlist_ in self.orderedlist:
            orderedlist_.export(outfile, level, namespace_, name_='orderedlist', pretty_print=pretty_print)
        for itemizedlist_ in self.itemizedlist:
            itemizedlist_.export(outfile, level, namespace_, name_='itemizedlist', pretty_print=pretty_print)
        for simplesect_ in self.simplesect:
            simplesect_.export(outfile, level, namespace_, name_='simplesect', pretty_print=pretty_print)
        for title_ in self.title:
            title_.export(outfile, level, namespace_, name_='title', pretty_print=pretty_print)
        for variablelist_ in self.variablelist:
            variablelist_.export(outfile, level, namespace_, name_='variablelist', pretty_print=pretty_print)
        for table_ in self.table:
            table_.export(outfile, level, namespace_, name_='table', pretty_print=pretty_print)
        for heading_ in self.heading:
            heading_.export(outfile, level, namespace_, name_='heading', pretty_print=pretty_print)
        for image_ in self.image:
            image_.export(outfile, level, namespace_, name_='image', pretty_print=pretty_print)
        for dotfile_ in self.dotfile:
            dotfile_.export(outfile, level, namespace_, name_='dotfile', pretty_print=pretty_print)
        for mscfile_ in self.mscfile:
            mscfile_.export(outfile, level, namespace_, name_='mscfile', pretty_print=pretty_print)
        for diafile_ in self.diafile:
            diafile_.export(outfile, level, namespace_, name_='diafile', pretty_print=pretty_print)
        for toclist_ in self.toclist:
            toclist_.export(outfile, level, namespace_, name_='toclist', pretty_print=pretty_print)
        for language_ in self.language:
            language_.export(outfile, level, namespace_, name_='language', pretty_print=pretty_print)
        for parameterlist_ in self.parameterlist:
            parameterlist_.export(outfile, level, namespace_, name_='parameterlist', pretty_print=pretty_print)
        for xrefsect_ in self.xrefsect:
            xrefsect_.export(outfile, level, namespace_, name_='xrefsect', pretty_print=pretty_print)
        for copydoc_ in self.copydoc:
            copydoc_.export(outfile, level, namespace_, name_='copydoc', pretty_print=pretty_print)
        for blockquote_ in self.blockquote:
            blockquote_.export(outfile, level, namespace_, name_='blockquote', pretty_print=pretty_print)
        for parblock_ in self.parblock:
            parblock_.export(outfile, level, namespace_, name_='parblock', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        elif nodeName_ == 'linebreak':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'linebreak', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_linebreak'):
              self.add_linebreak(obj_.value)
            elif hasattr(self, 'set_linebreak'):
              self.set_linebreak(obj_.value)
        elif nodeName_ == 'hruler':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hruler', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hruler'):
              self.add_hruler(obj_.value)
            elif hasattr(self, 'set_hruler'):
              self.set_hruler(obj_.value)
        elif nodeName_ == 'preformatted':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'preformatted', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_preformatted'):
              self.add_preformatted(obj_.value)
            elif hasattr(self, 'set_preformatted'):
              self.set_preformatted(obj_.value)
        elif nodeName_ == 'programlisting':
            obj_ = listingType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'programlisting', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_programlisting'):
              self.add_programlisting(obj_.value)
            elif hasattr(self, 'set_programlisting'):
              self.set_programlisting(obj_.value)
        elif nodeName_ == 'verbatim' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'verbatim', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'indexentry':
            obj_ = docIndexEntryType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'indexentry', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_indexentry'):
              self.add_indexentry(obj_.value)
            elif hasattr(self, 'set_indexentry'):
              self.set_indexentry(obj_.value)
        elif nodeName_ == 'orderedlist':
            obj_ = docListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'orderedlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_orderedlist'):
              self.add_orderedlist(obj_.value)
            elif hasattr(self, 'set_orderedlist'):
              self.set_orderedlist(obj_.value)
        elif nodeName_ == 'itemizedlist':
            obj_ = docListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'itemizedlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_itemizedlist'):
              self.add_itemizedlist(obj_.value)
            elif hasattr(self, 'set_itemizedlist'):
              self.set_itemizedlist(obj_.value)
        elif nodeName_ == 'simplesect':
            obj_ = docSimpleSectType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'simplesect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_simplesect'):
              self.add_simplesect(obj_.value)
            elif hasattr(self, 'set_simplesect'):
              self.set_simplesect(obj_.value)
        elif nodeName_ == 'title':
            obj_ = docTitleType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'title', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_title'):
              self.add_title(obj_.value)
            elif hasattr(self, 'set_title'):
              self.set_title(obj_.value)
        elif nodeName_ == 'variablelist':
            obj_ = docVariableListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'variablelist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_variablelist'):
              self.add_variablelist(obj_.value)
            elif hasattr(self, 'set_variablelist'):
              self.set_variablelist(obj_.value)
        elif nodeName_ == 'table':
            obj_ = docTableType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'table', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_table'):
              self.add_table(obj_.value)
            elif hasattr(self, 'set_table'):
              self.set_table(obj_.value)
        elif nodeName_ == 'heading':
            obj_ = docHeadingType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'heading', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_heading'):
              self.add_heading(obj_.value)
            elif hasattr(self, 'set_heading'):
              self.set_heading(obj_.value)
        elif nodeName_ == 'image':
            obj_ = docImageType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'image', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_image'):
              self.add_image(obj_.value)
            elif hasattr(self, 'set_image'):
              self.set_image(obj_.value)
        elif nodeName_ == 'dotfile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dotfile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dotfile'):
              self.add_dotfile(obj_.value)
            elif hasattr(self, 'set_dotfile'):
              self.set_dotfile(obj_.value)
        elif nodeName_ == 'mscfile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mscfile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mscfile'):
              self.add_mscfile(obj_.value)
            elif hasattr(self, 'set_mscfile'):
              self.set_mscfile(obj_.value)
        elif nodeName_ == 'diafile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diafile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diafile'):
              self.add_diafile(obj_.value)
            elif hasattr(self, 'set_diafile'):
              self.set_diafile(obj_.value)
        elif nodeName_ == 'toclist':
            obj_ = docTocListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'toclist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_toclist'):
              self.add_toclist(obj_.value)
            elif hasattr(self, 'set_toclist'):
              self.set_toclist(obj_.value)
        elif nodeName_ == 'language':
            obj_ = docLanguageType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'language', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_language'):
              self.add_language(obj_.value)
            elif hasattr(self, 'set_language'):
              self.set_language(obj_.value)
        elif nodeName_ == 'parameterlist':
            obj_ = docParamListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'parameterlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_parameterlist'):
              self.add_parameterlist(obj_.value)
            elif hasattr(self, 'set_parameterlist'):
              self.set_parameterlist(obj_.value)
        elif nodeName_ == 'xrefsect':
            obj_ = docXRefSectType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xrefsect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xrefsect'):
              self.add_xrefsect(obj_.value)
            elif hasattr(self, 'set_xrefsect'):
              self.set_xrefsect(obj_.value)
        elif nodeName_ == 'copydoc':
            obj_ = docCopyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copydoc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copydoc'):
              self.add_copydoc(obj_.value)
            elif hasattr(self, 'set_copydoc'):
              self.set_copydoc(obj_.value)
        elif nodeName_ == 'blockquote':
            obj_ = docBlockQuoteType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'blockquote', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_blockquote'):
              self.add_blockquote(obj_.value)
            elif hasattr(self, 'set_blockquote'):
              self.set_blockquote(obj_.value)
        elif nodeName_ == 'parblock':
            obj_ = docParBlockType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'parblock', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_parblock'):
              self.add_parblock(obj_.value)
            elif hasattr(self, 'set_parblock'):
              self.set_parblock(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docParaType


class docMarkupType(GeneratedsSuper):
    node_type = "docmarkup"

    subclass = None
    superclass = None
    def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, linebreak=None, hruler=None, preformatted=None, programlisting=None, verbatim=None, indexentry=None, orderedlist=None, itemizedlist=None, simplesect=None, title=None, variablelist=None, table=None, heading=None, image=None, dotfile=None, mscfile=None, diafile=None, toclist=None, language=None, parameterlist=None, xrefsect=None, copydoc=None, blockquote=None, parblock=None, valueOf_=None, mixedclass_=None, content_=None):
        self.type_ = None
        self.original_tagname_ = None
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        if linebreak is None:
            self.linebreak = []
        else:
            self.linebreak = linebreak
        if hruler is None:
            self.hruler = []
        else:
            self.hruler = hruler
        if preformatted is None:
            self.preformatted = []
        else:
            self.preformatted = preformatted
        if programlisting is None:
            self.programlisting = []
        else:
            self.programlisting = programlisting
        if verbatim is None:
            self.verbatim = []
        else:
            self.verbatim = verbatim
        if indexentry is None:
            self.indexentry = []
        else:
            self.indexentry = indexentry
        if orderedlist is None:
            self.orderedlist = []
        else:
            self.orderedlist = orderedlist
        if itemizedlist is None:
            self.itemizedlist = []
        else:
            self.itemizedlist = itemizedlist
        if simplesect is None:
            self.simplesect = []
        else:
            self.simplesect = simplesect
        if title is None:
            self.title = []
        else:
            self.title = title
        if variablelist is None:
            self.variablelist = []
        else:
            self.variablelist = variablelist
        if table is None:
            self.table = []
        else:
            self.table = table
        if heading is None:
            self.heading = []
        else:
            self.heading = heading
        if image is None:
            self.image = []
        else:
            self.image = image
        if dotfile is None:
            self.dotfile = []
        else:
            self.dotfile = dotfile
        if mscfile is None:
            self.mscfile = []
        else:
            self.mscfile = mscfile
        if diafile is None:
            self.diafile = []
        else:
            self.diafile = diafile
        if toclist is None:
            self.toclist = []
        else:
            self.toclist = toclist
        if language is None:
            self.language = []
        else:
            self.language = language
        if parameterlist is None:
            self.parameterlist = []
        else:
            self.parameterlist = parameterlist
        if xrefsect is None:
            self.xrefsect = []
        else:
            self.xrefsect = xrefsect
        if copydoc is None:
            self.copydoc = []
        else:
            self.copydoc = copydoc
        if blockquote is None:
            self.blockquote = []
        else:
            self.blockquote = blockquote
        if parblock is None:
            self.parblock = []
        else:
            self.parblock = parblock
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docMarkupType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docMarkupType.subclass:
            return docMarkupType.subclass(*args_, **kwargs_)
        else:
            return docMarkupType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_linebreak(self): return self.linebreak
    def set_linebreak(self, linebreak): self.linebreak = linebreak
    def add_linebreak(self, value): self.linebreak.append(value)
    def insert_linebreak_at(self, index, value): self.linebreak.insert(index, value)
    def replace_linebreak_at(self, index, value): self.linebreak[index] = value
    def get_hruler(self): return self.hruler
    def set_hruler(self, hruler): self.hruler = hruler
    def add_hruler(self, value): self.hruler.append(value)
    def insert_hruler_at(self, index, value): self.hruler.insert(index, value)
    def replace_hruler_at(self, index, value): self.hruler[index] = value
    def get_preformatted(self): return self.preformatted
    def set_preformatted(self, preformatted): self.preformatted = preformatted
    def add_preformatted(self, value): self.preformatted.append(value)
    def insert_preformatted_at(self, index, value): self.preformatted.insert(index, value)
    def replace_preformatted_at(self, index, value): self.preformatted[index] = value
    def get_programlisting(self): return self.programlisting
    def set_programlisting(self, programlisting): self.programlisting = programlisting
    def add_programlisting(self, value): self.programlisting.append(value)
    def insert_programlisting_at(self, index, value): self.programlisting.insert(index, value)
    def replace_programlisting_at(self, index, value): self.programlisting[index] = value
    def get_verbatim(self): return self.verbatim
    def set_verbatim(self, verbatim): self.verbatim = verbatim
    def add_verbatim(self, value): self.verbatim.append(value)
    def insert_verbatim_at(self, index, value): self.verbatim.insert(index, value)
    def replace_verbatim_at(self, index, value): self.verbatim[index] = value
    def get_indexentry(self): return self.indexentry
    def set_indexentry(self, indexentry): self.indexentry = indexentry
    def add_indexentry(self, value): self.indexentry.append(value)
    def insert_indexentry_at(self, index, value): self.indexentry.insert(index, value)
    def replace_indexentry_at(self, index, value): self.indexentry[index] = value
    def get_orderedlist(self): return self.orderedlist
    def set_orderedlist(self, orderedlist): self.orderedlist = orderedlist
    def add_orderedlist(self, value): self.orderedlist.append(value)
    def insert_orderedlist_at(self, index, value): self.orderedlist.insert(index, value)
    def replace_orderedlist_at(self, index, value): self.orderedlist[index] = value
    def get_itemizedlist(self): return self.itemizedlist
    def set_itemizedlist(self, itemizedlist): self.itemizedlist = itemizedlist
    def add_itemizedlist(self, value): self.itemizedlist.append(value)
    def insert_itemizedlist_at(self, index, value): self.itemizedlist.insert(index, value)
    def replace_itemizedlist_at(self, index, value): self.itemizedlist[index] = value
    def get_simplesect(self): return self.simplesect
    def set_simplesect(self, simplesect): self.simplesect = simplesect
    def add_simplesect(self, value): self.simplesect.append(value)
    def insert_simplesect_at(self, index, value): self.simplesect.insert(index, value)
    def replace_simplesect_at(self, index, value): self.simplesect[index] = value
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def add_title(self, value): self.title.append(value)
    def insert_title_at(self, index, value): self.title.insert(index, value)
    def replace_title_at(self, index, value): self.title[index] = value
    def get_variablelist(self): return self.variablelist
    def set_variablelist(self, variablelist): self.variablelist = variablelist
    def add_variablelist(self, value): self.variablelist.append(value)
    def insert_variablelist_at(self, index, value): self.variablelist.insert(index, value)
    def replace_variablelist_at(self, index, value): self.variablelist[index] = value
    def get_table(self): return self.table
    def set_table(self, table): self.table = table
    def add_table(self, value): self.table.append(value)
    def insert_table_at(self, index, value): self.table.insert(index, value)
    def replace_table_at(self, index, value): self.table[index] = value
    def get_heading(self): return self.heading
    def set_heading(self, heading): self.heading = heading
    def add_heading(self, value): self.heading.append(value)
    def insert_heading_at(self, index, value): self.heading.insert(index, value)
    def replace_heading_at(self, index, value): self.heading[index] = value
    def get_image(self): return self.image
    def set_image(self, image): self.image = image
    def add_image(self, value): self.image.append(value)
    def insert_image_at(self, index, value): self.image.insert(index, value)
    def replace_image_at(self, index, value): self.image[index] = value
    def get_dotfile(self): return self.dotfile
    def set_dotfile(self, dotfile): self.dotfile = dotfile
    def add_dotfile(self, value): self.dotfile.append(value)
    def insert_dotfile_at(self, index, value): self.dotfile.insert(index, value)
    def replace_dotfile_at(self, index, value): self.dotfile[index] = value
    def get_mscfile(self): return self.mscfile
    def set_mscfile(self, mscfile): self.mscfile = mscfile
    def add_mscfile(self, value): self.mscfile.append(value)
    def insert_mscfile_at(self, index, value): self.mscfile.insert(index, value)
    def replace_mscfile_at(self, index, value): self.mscfile[index] = value
    def get_diafile(self): return self.diafile
    def set_diafile(self, diafile): self.diafile = diafile
    def add_diafile(self, value): self.diafile.append(value)
    def insert_diafile_at(self, index, value): self.diafile.insert(index, value)
    def replace_diafile_at(self, index, value): self.diafile[index] = value
    def get_toclist(self): return self.toclist
    def set_toclist(self, toclist): self.toclist = toclist
    def add_toclist(self, value): self.toclist.append(value)
    def insert_toclist_at(self, index, value): self.toclist.insert(index, value)
    def replace_toclist_at(self, index, value): self.toclist[index] = value
    def get_language(self): return self.language
    def set_language(self, language): self.language = language
    def add_language(self, value): self.language.append(value)
    def insert_language_at(self, index, value): self.language.insert(index, value)
    def replace_language_at(self, index, value): self.language[index] = value
    def get_parameterlist(self): return self.parameterlist
    def set_parameterlist(self, parameterlist): self.parameterlist = parameterlist
    def add_parameterlist(self, value): self.parameterlist.append(value)
    def insert_parameterlist_at(self, index, value): self.parameterlist.insert(index, value)
    def replace_parameterlist_at(self, index, value): self.parameterlist[index] = value
    def get_xrefsect(self): return self.xrefsect
    def set_xrefsect(self, xrefsect): self.xrefsect = xrefsect
    def add_xrefsect(self, value): self.xrefsect.append(value)
    def insert_xrefsect_at(self, index, value): self.xrefsect.insert(index, value)
    def replace_xrefsect_at(self, index, value): self.xrefsect[index] = value
    def get_copydoc(self): return self.copydoc
    def set_copydoc(self, copydoc): self.copydoc = copydoc
    def add_copydoc(self, value): self.copydoc.append(value)
    def insert_copydoc_at(self, index, value): self.copydoc.insert(index, value)
    def replace_copydoc_at(self, index, value): self.copydoc[index] = value
    def get_blockquote(self): return self.blockquote
    def set_blockquote(self, blockquote): self.blockquote = blockquote
    def add_blockquote(self, value): self.blockquote.append(value)
    def insert_blockquote_at(self, index, value): self.blockquote.insert(index, value)
    def replace_blockquote_at(self, index, value): self.blockquote[index] = value
    def get_parblock(self): return self.parblock
    def set_parblock(self, parblock): self.parblock = parblock
    def add_parblock(self, value): self.parblock.append(value)
    def insert_parblock_at(self, index, value): self.parblock.insert(index, value)
    def replace_parblock_at(self, index, value): self.parblock[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            self.linebreak or
            self.hruler or
            self.preformatted or
            self.programlisting or
            self.verbatim or
            self.indexentry or
            self.orderedlist or
            self.itemizedlist or
            self.simplesect or
            self.title or
            self.variablelist or
            self.table or
            self.heading or
            self.image or
            self.dotfile or
            self.mscfile or
            self.diafile or
            self.toclist or
            self.language or
            self.parameterlist or
            self.xrefsect or
            self.copydoc or
            self.blockquote or
            self.parblock or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docMarkupType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docMarkupType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docMarkupType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docMarkupType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docMarkupType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docMarkupType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
        for linebreak_ in self.linebreak:
            linebreak_.export(outfile, level, namespace_, name_='linebreak', pretty_print=pretty_print)
        for hruler_ in self.hruler:
            hruler_.export(outfile, level, namespace_, name_='hruler', pretty_print=pretty_print)
        for preformatted_ in self.preformatted:
            preformatted_.export(outfile, level, namespace_, name_='preformatted', pretty_print=pretty_print)
        for programlisting_ in self.programlisting:
            programlisting_.export(outfile, level, namespace_, name_='programlisting', pretty_print=pretty_print)
        for verbatim_ in self.verbatim:
            showIndent(outfile, level, pretty_print)
            outfile.write('<verbatim>%s</verbatim>%s' % (self.gds_encode(self.gds_format_string(quote_xml(verbatim_), input_name='verbatim')), eol_))
        for indexentry_ in self.indexentry:
            indexentry_.export(outfile, level, namespace_, name_='indexentry', pretty_print=pretty_print)
        for orderedlist_ in self.orderedlist:
            orderedlist_.export(outfile, level, namespace_, name_='orderedlist', pretty_print=pretty_print)
        for itemizedlist_ in self.itemizedlist:
            itemizedlist_.export(outfile, level, namespace_, name_='itemizedlist', pretty_print=pretty_print)
        for simplesect_ in self.simplesect:
            simplesect_.export(outfile, level, namespace_, name_='simplesect', pretty_print=pretty_print)
        for title_ in self.title:
            title_.export(outfile, level, namespace_, name_='title', pretty_print=pretty_print)
        for variablelist_ in self.variablelist:
            variablelist_.export(outfile, level, namespace_, name_='variablelist', pretty_print=pretty_print)
        for table_ in self.table:
            table_.export(outfile, level, namespace_, name_='table', pretty_print=pretty_print)
        for heading_ in self.heading:
            heading_.export(outfile, level, namespace_, name_='heading', pretty_print=pretty_print)
        for image_ in self.image:
            image_.export(outfile, level, namespace_, name_='image', pretty_print=pretty_print)
        for dotfile_ in self.dotfile:
            dotfile_.export(outfile, level, namespace_, name_='dotfile', pretty_print=pretty_print)
        for mscfile_ in self.mscfile:
            mscfile_.export(outfile, level, namespace_, name_='mscfile', pretty_print=pretty_print)
        for diafile_ in self.diafile:
            diafile_.export(outfile, level, namespace_, name_='diafile', pretty_print=pretty_print)
        for toclist_ in self.toclist:
            toclist_.export(outfile, level, namespace_, name_='toclist', pretty_print=pretty_print)
        for language_ in self.language:
            language_.export(outfile, level, namespace_, name_='language', pretty_print=pretty_print)
        for parameterlist_ in self.parameterlist:
            parameterlist_.export(outfile, level, namespace_, name_='parameterlist', pretty_print=pretty_print)
        for xrefsect_ in self.xrefsect:
            xrefsect_.export(outfile, level, namespace_, name_='xrefsect', pretty_print=pretty_print)
        for copydoc_ in self.copydoc:
            copydoc_.export(outfile, level, namespace_, name_='copydoc', pretty_print=pretty_print)
        for blockquote_ in self.blockquote:
            blockquote_.export(outfile, level, namespace_, name_='blockquote', pretty_print=pretty_print)
        for parblock_ in self.parblock:
            parblock_.export(outfile, level, namespace_, name_='parblock', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        elif nodeName_ == 'linebreak':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'linebreak', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_linebreak'):
              self.add_linebreak(obj_.value)
            elif hasattr(self, 'set_linebreak'):
              self.set_linebreak(obj_.value)
        elif nodeName_ == 'hruler':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hruler', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hruler'):
              self.add_hruler(obj_.value)
            elif hasattr(self, 'set_hruler'):
              self.set_hruler(obj_.value)
        elif nodeName_ == 'preformatted':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'preformatted', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_preformatted'):
              self.add_preformatted(obj_.value)
            elif hasattr(self, 'set_preformatted'):
              self.set_preformatted(obj_.value)
        elif nodeName_ == 'programlisting':
            obj_ = listingType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'programlisting', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_programlisting'):
              self.add_programlisting(obj_.value)
            elif hasattr(self, 'set_programlisting'):
              self.set_programlisting(obj_.value)
        elif nodeName_ == 'verbatim' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'verbatim', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'indexentry':
            obj_ = docIndexEntryType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'indexentry', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_indexentry'):
              self.add_indexentry(obj_.value)
            elif hasattr(self, 'set_indexentry'):
              self.set_indexentry(obj_.value)
        elif nodeName_ == 'orderedlist':
            obj_ = docListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'orderedlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_orderedlist'):
              self.add_orderedlist(obj_.value)
            elif hasattr(self, 'set_orderedlist'):
              self.set_orderedlist(obj_.value)
        elif nodeName_ == 'itemizedlist':
            obj_ = docListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'itemizedlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_itemizedlist'):
              self.add_itemizedlist(obj_.value)
            elif hasattr(self, 'set_itemizedlist'):
              self.set_itemizedlist(obj_.value)
        elif nodeName_ == 'simplesect':
            obj_ = docSimpleSectType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'simplesect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_simplesect'):
              self.add_simplesect(obj_.value)
            elif hasattr(self, 'set_simplesect'):
              self.set_simplesect(obj_.value)
        elif nodeName_ == 'title':
            obj_ = docTitleType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'title', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_title'):
              self.add_title(obj_.value)
            elif hasattr(self, 'set_title'):
              self.set_title(obj_.value)
        elif nodeName_ == 'variablelist':
            obj_ = docVariableListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'variablelist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_variablelist'):
              self.add_variablelist(obj_.value)
            elif hasattr(self, 'set_variablelist'):
              self.set_variablelist(obj_.value)
        elif nodeName_ == 'table':
            obj_ = docTableType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'table', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_table'):
              self.add_table(obj_.value)
            elif hasattr(self, 'set_table'):
              self.set_table(obj_.value)
        elif nodeName_ == 'heading':
            obj_ = docHeadingType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'heading', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_heading'):
              self.add_heading(obj_.value)
            elif hasattr(self, 'set_heading'):
              self.set_heading(obj_.value)
        elif nodeName_ == 'image':
            obj_ = docImageType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'image', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_image'):
              self.add_image(obj_.value)
            elif hasattr(self, 'set_image'):
              self.set_image(obj_.value)
        elif nodeName_ == 'dotfile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dotfile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dotfile'):
              self.add_dotfile(obj_.value)
            elif hasattr(self, 'set_dotfile'):
              self.set_dotfile(obj_.value)
        elif nodeName_ == 'mscfile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mscfile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mscfile'):
              self.add_mscfile(obj_.value)
            elif hasattr(self, 'set_mscfile'):
              self.set_mscfile(obj_.value)
        elif nodeName_ == 'diafile':
            obj_ = docFileType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diafile', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diafile'):
              self.add_diafile(obj_.value)
            elif hasattr(self, 'set_diafile'):
              self.set_diafile(obj_.value)
        elif nodeName_ == 'toclist':
            obj_ = docTocListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'toclist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_toclist'):
              self.add_toclist(obj_.value)
            elif hasattr(self, 'set_toclist'):
              self.set_toclist(obj_.value)
        elif nodeName_ == 'language':
            obj_ = docLanguageType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'language', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_language'):
              self.add_language(obj_.value)
            elif hasattr(self, 'set_language'):
              self.set_language(obj_.value)
        elif nodeName_ == 'parameterlist':
            obj_ = docParamListType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'parameterlist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_parameterlist'):
              self.add_parameterlist(obj_.value)
            elif hasattr(self, 'set_parameterlist'):
              self.set_parameterlist(obj_.value)
        elif nodeName_ == 'xrefsect':
            obj_ = docXRefSectType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xrefsect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xrefsect'):
              self.add_xrefsect(obj_.value)
            elif hasattr(self, 'set_xrefsect'):
              self.set_xrefsect(obj_.value)
        elif nodeName_ == 'copydoc':
            obj_ = docCopyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copydoc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copydoc'):
              self.add_copydoc(obj_.value)
            elif hasattr(self, 'set_copydoc'):
              self.set_copydoc(obj_.value)
        elif nodeName_ == 'blockquote':
            obj_ = docBlockQuoteType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'blockquote', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_blockquote'):
              self.add_blockquote(obj_.value)
            elif hasattr(self, 'set_blockquote'):
              self.set_blockquote(obj_.value)
        elif nodeName_ == 'parblock':
            obj_ = docParBlockType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'parblock', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_parblock'):
              self.add_parblock(obj_.value)
            elif hasattr(self, 'set_parblock'):
              self.set_parblock(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docMarkupType


class docURLLink(GeneratedsSuper):
    node_type = "docurllink"

    subclass = None
    superclass = None
    def __init__(self, url=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.url = _cast(None, url)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docURLLink)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docURLLink.subclass:
            return docURLLink.subclass(*args_, **kwargs_)
        else:
            return docURLLink(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_url(self): return self.url
    def set_url(self, url): self.url = url
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docURLLink', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docURLLink')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docURLLink')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docURLLink', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docURLLink'):
        if self.url is not None and 'url' not in already_processed:
            already_processed.add('url')
            outfile.write(' url=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.url), input_name='url')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docURLLink', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('url', node)
        if value is not None and 'url' not in already_processed:
            already_processed.add('url')
            self.url = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docURLLink


class docAnchorType(GeneratedsSuper):
    node_type = "docanchor"

    subclass = None
    superclass = None
    def __init__(self, id=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docAnchorType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docAnchorType.subclass:
            return docAnchorType.subclass(*args_, **kwargs_)
        else:
            return docAnchorType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docAnchorType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docAnchorType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docAnchorType')
        outfile.write('>')
        self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print)
        outfile.write(self.convert_unicode(self.valueOf_))
        outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docAnchorType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docAnchorType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
        pass
# end class docAnchorType


class docFormulaType(GeneratedsSuper):
    node_type = "docformula"

    subclass = None
    superclass = None
    def __init__(self, id=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docFormulaType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docFormulaType.subclass:
            return docFormulaType.subclass(*args_, **kwargs_)
        else:
            return docFormulaType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docFormulaType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docFormulaType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docFormulaType')
        outfile.write('>')
        self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print)
        outfile.write(self.convert_unicode(self.valueOf_))
        outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docFormulaType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docFormulaType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
        pass
# end class docFormulaType


class docIndexEntryType(GeneratedsSuper):
    node_type = "docindexentry"

    subclass = None
    superclass = None
    def __init__(self, primaryie=None, secondaryie=None):
        self.original_tagname_ = None
        self.primaryie = primaryie
        self.secondaryie = secondaryie
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docIndexEntryType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docIndexEntryType.subclass:
            return docIndexEntryType.subclass(*args_, **kwargs_)
        else:
            return docIndexEntryType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_primaryie(self): return self.primaryie
    def set_primaryie(self, primaryie): self.primaryie = primaryie
    def get_secondaryie(self): return self.secondaryie
    def set_secondaryie(self, secondaryie): self.secondaryie = secondaryie
    def hasContent_(self):
        if (
            self.primaryie is not None or
            self.secondaryie is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docIndexEntryType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docIndexEntryType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docIndexEntryType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docIndexEntryType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docIndexEntryType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docIndexEntryType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.primaryie is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<primaryie>%s</primaryie>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.primaryie), input_name='primaryie')), eol_))
        if self.secondaryie is not None:
            showIndent(outfile, level, pretty_print)
            outfile.write('<secondaryie>%s</secondaryie>%s' % (self.gds_encode(self.gds_format_string(quote_xml(self.secondaryie), input_name='secondaryie')), eol_))
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'primaryie':
            primaryie_ = child_.text
            primaryie_ = self.gds_validate_string(primaryie_, node, 'primaryie')
            self.primaryie = primaryie_
        elif nodeName_ == 'secondaryie':
            secondaryie_ = child_.text
            secondaryie_ = self.gds_validate_string(secondaryie_, node, 'secondaryie')
            self.secondaryie = secondaryie_
# end class docIndexEntryType


class docListType(GeneratedsSuper):
    node_type = "doclist"

    subclass = None
    superclass = None
    def __init__(self, listitem=None):
        self.original_tagname_ = None
        if listitem is None:
            self.listitem = []
        else:
            self.listitem = listitem
        self.node_subtype = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docListType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docListType.subclass:
            return docListType.subclass(*args_, **kwargs_)
        else:
            return docListType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_listitem(self): return self.listitem
    def set_listitem(self, listitem): self.listitem = listitem
    def add_listitem(self, value): self.listitem.append(value)
    def insert_listitem_at(self, index, value): self.listitem.insert(index, value)
    def replace_listitem_at(self, index, value): self.listitem[index] = value
    def hasContent_(self):
        if (
            self.listitem
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docListType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docListType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docListType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docListType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docListType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docListType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for listitem_ in self.listitem:
            listitem_.export(outfile, level, namespace_, name_='listitem', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'listitem':
            obj_ = docListItemType.factory()
            obj_.build(child_)
            self.listitem.append(obj_)
            obj_.original_tagname_ = 'listitem'
# end class docListType


class docListItemType(GeneratedsSuper):
    node_type = "doclistitem"

    subclass = None
    superclass = None
    def __init__(self, para=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docListItemType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docListItemType.subclass:
            return docListItemType.subclass(*args_, **kwargs_)
        else:
            return docListItemType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def hasContent_(self):
        if (
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docListItemType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docListItemType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docListItemType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docListItemType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docListItemType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docListItemType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docListItemType


class docSimpleSectType(GeneratedsSuper):
    node_type = "docsimplesect"

    subclass = None
    superclass = None
    def __init__(self, kind=None, title=None, para=None):
        self.original_tagname_ = None
        self.kind = _cast(None, kind)
        self.title = title
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docSimpleSectType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docSimpleSectType.subclass:
            return docSimpleSectType.subclass(*args_, **kwargs_)
        else:
            return docSimpleSectType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_title(self): return self.title
    def set_title(self, title): self.title = title
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def validate_DoxSimpleSectKind(self, value):
        # Validate type DoxSimpleSectKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['see', 'return', 'author', 'authors', 'version', 'since', 'date', 'note', 'warning', 'pre', 'post', 'copyright', 'invariant', 'remark', 'attention', 'par', 'rcs']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxSimpleSectKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.title is not None or
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docSimpleSectType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docSimpleSectType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docSimpleSectType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docSimpleSectType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docSimpleSectType'):
        if self.kind is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docSimpleSectType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.title is not None:
            self.title.export(outfile, level, namespace_, name_='title', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('kind', node)
        if value is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            self.kind = value
            self.validate_DoxSimpleSectKind(self.kind)    # validate type DoxSimpleSectKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'title':
            obj_ = docTitleType.factory()
            obj_.build(child_)
            self.title = obj_
            obj_.original_tagname_ = 'title'
        elif nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docSimpleSectType


class docVarListEntryType(GeneratedsSuper):
    node_type = "docvarlistentry"

    subclass = None
    superclass = None
    def __init__(self, term=None):
        self.original_tagname_ = None
        self.term = term
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docVarListEntryType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docVarListEntryType.subclass:
            return docVarListEntryType.subclass(*args_, **kwargs_)
        else:
            return docVarListEntryType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_term(self): return self.term
    def set_term(self, term): self.term = term
    def hasContent_(self):
        if (
            self.term is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docVarListEntryType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docVarListEntryType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docVarListEntryType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docVarListEntryType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docVarListEntryType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docVarListEntryType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.term is not None:
            self.term.export(outfile, level, namespace_, name_='term', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'term':
            obj_ = docTitleType.factory()
            obj_.build(child_)
            self.term = obj_
            obj_.original_tagname_ = 'term'
# end class docVarListEntryType


class docVariableListType(GeneratedsSuper):
    node_type = "docvarlist"

    subclass = None
    superclass = None
    def __init__(self, varlistentry=None, listitem=None):
        self.original_tagname_ = None
        if varlistentry is None:
            self.varlistentry = []
        else:
            self.varlistentry = varlistentry
        if listitem is None:
            self.listitem = []
        else:
            self.listitem = listitem
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docVariableListType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docVariableListType.subclass:
            return docVariableListType.subclass(*args_, **kwargs_)
        else:
            return docVariableListType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_varlistentry(self): return self.varlistentry
    def set_varlistentry(self, varlistentry): self.varlistentry = varlistentry
    def add_varlistentry(self, value): self.varlistentry.append(value)
    def insert_varlistentry_at(self, index, value): self.varlistentry.insert(index, value)
    def replace_varlistentry_at(self, index, value): self.varlistentry[index] = value
    def get_listitem(self): return self.listitem
    def set_listitem(self, listitem): self.listitem = listitem
    def add_listitem(self, value): self.listitem.append(value)
    def insert_listitem_at(self, index, value): self.listitem.insert(index, value)
    def replace_listitem_at(self, index, value): self.listitem[index] = value
    def hasContent_(self):
        if (
            self.varlistentry or
            self.listitem
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docVariableListType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docVariableListType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docVariableListType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docVariableListType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docVariableListType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docVariableListType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for varlistentry_ in self.varlistentry:
            varlistentry_.export(outfile, level, namespace_, name_='varlistentry', pretty_print=pretty_print)
        for listitem_ in self.listitem:
            listitem_.export(outfile, level, namespace_, name_='listitem', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'varlistentry':
            obj_ = docVarListEntryType.factory()
            obj_.build(child_)
            self.varlistentry.append(obj_)
            obj_.original_tagname_ = 'varlistentry'
        elif nodeName_ == 'listitem':
            obj_ = docListItemType.factory()
            obj_.build(child_)
            self.listitem.append(obj_)
            obj_.original_tagname_ = 'listitem'
# end class docVariableListType


class docRefTextType(GeneratedsSuper):
    node_type = "docreftext"

    subclass = None
    superclass = None
    def __init__(self, refid=None, kindref=None, external=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.refid = _cast(None, refid)
        self.kindref = _cast(None, kindref)
        self.external = _cast(None, external)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docRefTextType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docRefTextType.subclass:
            return docRefTextType.subclass(*args_, **kwargs_)
        else:
            return docRefTextType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def get_kindref(self): return self.kindref
    def set_kindref(self, kindref): self.kindref = kindref
    def get_external(self): return self.external
    def set_external(self, external): self.external = external
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxRefKind(self, value):
        # Validate type DoxRefKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['compound', 'member']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxRefKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docRefTextType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docRefTextType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docRefTextType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docRefTextType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docRefTextType'):
        if self.refid is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            outfile.write(' refid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.refid), input_name='refid')), ))
        if self.kindref is not None and 'kindref' not in already_processed:
            already_processed.add('kindref')
            outfile.write(' kindref=%s' % (quote_attrib(self.kindref), ))
        if self.external is not None and 'external' not in already_processed:
            already_processed.add('external')
            outfile.write(' external=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.external), input_name='external')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docRefTextType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('refid', node)
        if value is not None and 'refid' not in already_processed:
            already_processed.add('refid')
            self.refid = value
        value = find_attr_value_('kindref', node)
        if value is not None and 'kindref' not in already_processed:
            already_processed.add('kindref')
            self.kindref = value
            self.validate_DoxRefKind(self.kindref)    # validate type DoxRefKind
        value = find_attr_value_('external', node)
        if value is not None and 'external' not in already_processed:
            already_processed.add('external')
            self.external = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docRefTextType


class docTableType(GeneratedsSuper):
    node_type = "doctable"

    subclass = None
    superclass = None
    def __init__(self, rows=None, cols=None, row=None, caption=None):
        self.original_tagname_ = None
        self.rows = _cast(int, rows)
        self.cols = _cast(int, cols)
        if row is None:
            self.row = []
        else:
            self.row = row
        self.caption = caption
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docTableType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docTableType.subclass:
            return docTableType.subclass(*args_, **kwargs_)
        else:
            return docTableType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_row(self): return self.row
    def set_row(self, row): self.row = row
    def add_row(self, value): self.row.append(value)
    def insert_row_at(self, index, value): self.row.insert(index, value)
    def replace_row_at(self, index, value): self.row[index] = value
    def get_caption(self): return self.caption
    def set_caption(self, caption): self.caption = caption
    def get_rows(self): return self.rows
    def set_rows(self, rows): self.rows = rows
    def get_cols(self): return self.cols
    def set_cols(self, cols): self.cols = cols
    def hasContent_(self):
        if (
            self.row or
            self.caption is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docTableType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTableType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docTableType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docTableType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docTableType'):
        if self.rows is not None and 'rows' not in already_processed:
            already_processed.add('rows')
            outfile.write(' rows="%s"' % self.gds_format_integer(self.rows, input_name='rows'))
        if self.cols is not None and 'cols' not in already_processed:
            already_processed.add('cols')
            outfile.write(' cols="%s"' % self.gds_format_integer(self.cols, input_name='cols'))
    def exportChildren(self, outfile, level, namespace_='', name_='docTableType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for row_ in self.row:
            row_.export(outfile, level, namespace_, name_='row', pretty_print=pretty_print)
        if self.caption is not None:
            self.caption.export(outfile, level, namespace_, name_='caption', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('rows', node)
        if value is not None and 'rows' not in already_processed:
            already_processed.add('rows')
            try:
                self.rows = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
        value = find_attr_value_('cols', node)
        if value is not None and 'cols' not in already_processed:
            already_processed.add('cols')
            try:
                self.cols = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'row':
            obj_ = docRowType.factory()
            obj_.build(child_)
            self.row.append(obj_)
            obj_.original_tagname_ = 'row'
        elif nodeName_ == 'caption':
            obj_ = docCaptionType.factory()
            obj_.build(child_)
            self.caption = obj_
            obj_.original_tagname_ = 'caption'
# end class docTableType


class docRowType(GeneratedsSuper):
    node_type = "docrow"

    subclass = None
    superclass = None
    def __init__(self, entry=None):
        self.original_tagname_ = None
        if entry is None:
            self.entry = []
        else:
            self.entry = entry
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docRowType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docRowType.subclass:
            return docRowType.subclass(*args_, **kwargs_)
        else:
            return docRowType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_entry(self): return self.entry
    def set_entry(self, entry): self.entry = entry
    def add_entry(self, value): self.entry.append(value)
    def insert_entry_at(self, index, value): self.entry.insert(index, value)
    def replace_entry_at(self, index, value): self.entry[index] = value
    def hasContent_(self):
        if (
            self.entry
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docRowType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docRowType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docRowType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docRowType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docRowType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docRowType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for entry_ in self.entry:
            entry_.export(outfile, level, namespace_, name_='entry', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'entry':
            obj_ = docEntryType.factory()
            obj_.build(child_)
            self.entry.append(obj_)
            obj_.original_tagname_ = 'entry'
# end class docRowType


class docEntryType(GeneratedsSuper):
    node_type = "docentry"

    subclass = None
    superclass = None
    def __init__(self, thead=None, para=None):
        self.original_tagname_ = None
        self.thead = _cast(None, thead)
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docEntryType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docEntryType.subclass:
            return docEntryType.subclass(*args_, **kwargs_)
        else:
            return docEntryType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_thead(self): return self.thead
    def set_thead(self, thead): self.thead = thead
    def validate_DoxBool(self, value):
        # Validate type DoxBool, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['yes', 'no']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxBool' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docEntryType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docEntryType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docEntryType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docEntryType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docEntryType'):
        if self.thead is not None and 'thead' not in already_processed:
            already_processed.add('thead')
            outfile.write(' thead=%s' % (quote_attrib(self.thead), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docEntryType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('thead', node)
        if value is not None and 'thead' not in already_processed:
            already_processed.add('thead')
            self.thead = value
            self.validate_DoxBool(self.thead)    # validate type DoxBool
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docEntryType


class docCaptionType(GeneratedsSuper):
    node_type = "doccaption"

    subclass = None
    superclass = None
    def __init__(self, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docCaptionType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docCaptionType.subclass:
            return docCaptionType.subclass(*args_, **kwargs_)
        else:
            return docCaptionType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docCaptionType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docCaptionType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docCaptionType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docCaptionType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docCaptionType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docCaptionType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docCaptionType


class docHeadingType(GeneratedsSuper):
    node_type = "docheading"

    subclass = None
    superclass = None
    def __init__(self, level=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.level = _cast(int, level)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docHeadingType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docHeadingType.subclass:
            return docHeadingType.subclass(*args_, **kwargs_)
        else:
            return docHeadingType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_level(self): return self.level
    def set_level(self, level): self.level = level
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docHeadingType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docHeadingType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docHeadingType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docHeadingType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docHeadingType'):
        if self.level is not None and 'level' not in already_processed:
            already_processed.add('level')
            outfile.write(' level="%s"' % self.gds_format_integer(self.level, input_name='level'))
    def exportChildren(self, outfile, level, namespace_='', name_='docHeadingType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('level', node)
        if value is not None and 'level' not in already_processed:
            already_processed.add('level')
            try:
                self.level = int(value)
            except ValueError as exp:
                raise_parse_error(node, 'Bad integer attribute: %s' % exp)
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docHeadingType


class docImageType(GeneratedsSuper):
    node_type = "docimage"

    subclass = None
    superclass = None
    def __init__(self, type_=None, name=None, width=None, height=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.type_ = _cast(None, type_)
        self.name = _cast(None, name)
        self.width = _cast(None, width)
        self.height = _cast(None, height)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docImageType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docImageType.subclass:
            return docImageType.subclass(*args_, **kwargs_)
        else:
            return docImageType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_type(self): return self.type_
    def set_type(self, type_): self.type_ = type_
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_width(self): return self.width
    def set_width(self, width): self.width = width
    def get_height(self): return self.height
    def set_height(self, height): self.height = height
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxImageKind(self, value):
        # Validate type DoxImageKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['html', 'latex', 'rtf']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxImageKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docImageType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docImageType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docImageType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docImageType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docImageType'):
        if self.type_ is not None and 'type_' not in already_processed:
            already_processed.add('type_')
            outfile.write(' type=%s' % (quote_attrib(self.type_), ))
        if self.name is not None and 'name' not in already_processed:
            already_processed.add('name')
            outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), ))
        if self.width is not None and 'width' not in already_processed:
            already_processed.add('width')
            outfile.write(' width=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.width), input_name='width')), ))
        if self.height is not None and 'height' not in already_processed:
            already_processed.add('height')
            outfile.write(' height=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.height), input_name='height')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docImageType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('type', node)
        if value is not None and 'type' not in already_processed:
            already_processed.add('type')
            self.type_ = value
            self.validate_DoxImageKind(self.type_)    # validate type DoxImageKind
        value = find_attr_value_('name', node)
        if value is not None and 'name' not in already_processed:
            already_processed.add('name')
            self.name = value
        value = find_attr_value_('width', node)
        if value is not None and 'width' not in already_processed:
            already_processed.add('width')
            self.width = value
        value = find_attr_value_('height', node)
        if value is not None and 'height' not in already_processed:
            already_processed.add('height')
            self.height = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docImageType


class docFileType(GeneratedsSuper):
    node_type = "docfile"

    subclass = None
    superclass = None
    def __init__(self, name=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.name = _cast(None, name)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docFileType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docFileType.subclass:
            return docFileType.subclass(*args_, **kwargs_)
        else:
            return docFileType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docFileType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docFileType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docFileType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docFileType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docFileType'):
        if self.name is not None and 'name' not in already_processed:
            already_processed.add('name')
            outfile.write(' name=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.name), input_name='name')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docFileType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('name', node)
        if value is not None and 'name' not in already_processed:
            already_processed.add('name')
            self.name = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docFileType


class docTocItemType(GeneratedsSuper):
    node_type = "doctocitem"

    subclass = None
    superclass = None
    def __init__(self, id=None, ulink=None, bold=None, emphasis=None, computeroutput=None, subscript=None, superscript=None, center=None, small=None, htmlonly=None, manonly=None, xmlonly=None, rtfonly=None, latexonly=None, dot=None, plantuml=None, anchor=None, formula=None, ref=None, nonbreakablespace=None, iexcl=None, cent=None, pound=None, curren=None, yen=None, brvbar=None, sect=None, umlaut=None, copy=None, ordf=None, laquo=None, not_=None, shy=None, registered=None, macr=None, deg=None, plusmn=None, sup2=None, sup3=None, acute=None, micro=None, para=None, middot=None, cedil=None, sup1=None, ordm=None, raquo=None, frac14=None, frac12=None, frac34=None, iquest=None, Agrave=None, Aacute=None, Acirc=None, Atilde=None, Aumlaut=None, Aring=None, AElig=None, Ccedil=None, Egrave=None, Eacute=None, Ecirc=None, Eumlaut=None, Igrave=None, Iacute=None, Icirc=None, Iumlaut=None, ETH=None, Ntilde=None, Ograve=None, Oacute=None, Ocirc=None, Otilde=None, Oumlaut=None, times=None, Oslash=None, Ugrave=None, Uacute=None, Ucirc=None, Uumlaut=None, Yacute=None, THORN=None, szlig=None, agrave=None, aacute=None, acirc=None, atilde=None, aumlaut=None, aring=None, aelig=None, ccedil=None, egrave=None, eacute=None, ecirc=None, eumlaut=None, igrave=None, iacute=None, icirc=None, iumlaut=None, eth=None, ntilde=None, ograve=None, oacute=None, ocirc=None, otilde=None, oumlaut=None, divide=None, oslash=None, ugrave=None, uacute=None, ucirc=None, uumlaut=None, yacute=None, thorn=None, yumlaut=None, fnof=None, Alpha=None, Beta=None, Gamma=None, Delta=None, Epsilon=None, Zeta=None, Eta=None, Theta=None, Iota=None, Kappa=None, Lambda=None, Mu=None, Nu=None, Xi=None, Omicron=None, Pi=None, Rho=None, Sigma=None, Tau=None, Upsilon=None, Phi=None, Chi=None, Psi=None, Omega=None, alpha=None, beta=None, gamma=None, delta=None, epsilon=None, zeta=None, eta=None, theta=None, iota=None, kappa=None, lambda_=None, mu=None, nu=None, xi=None, omicron=None, pi=None, rho=None, sigmaf=None, sigma=None, tau=None, upsilon=None, phi=None, chi=None, psi=None, omega=None, thetasym=None, upsih=None, piv=None, bull=None, hellip=None, prime=None, Prime=None, oline=None, frasl=None, weierp=None, imaginary=None, real=None, trademark=None, alefsym=None, larr=None, uarr=None, rarr=None, darr=None, harr=None, crarr=None, lArr=None, uArr=None, rArr=None, dArr=None, hArr=None, forall=None, part=None, exist=None, empty=None, nabla=None, isin=None, notin=None, ni=None, prod=None, sum=None, minus=None, lowast=None, radic=None, prop=None, infin=None, ang=None, and_=None, or_=None, cap=None, cup=None, int=None, there4=None, sim=None, cong=None, asymp=None, ne=None, equiv=None, le=None, ge=None, sub=None, sup=None, nsub=None, sube=None, supe=None, oplus=None, otimes=None, perp=None, sdot=None, lceil=None, rceil=None, lfloor=None, rfloor=None, lang=None, rang=None, loz=None, spades=None, clubs=None, hearts=None, diams=None, OElig=None, oelig=None, Scaron=None, scaron=None, Yumlaut=None, circ=None, tilde=None, ensp=None, emsp=None, thinsp=None, zwnj=None, zwj=None, lrm=None, rlm=None, ndash=None, mdash=None, lsquo=None, rsquo=None, sbquo=None, ldquo=None, rdquo=None, bdquo=None, dagger=None, Dagger=None, permil=None, lsaquo=None, rsaquo=None, euro=None, tm=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        if ulink is None:
            self.ulink = []
        else:
            self.ulink = ulink
        if bold is None:
            self.bold = []
        else:
            self.bold = bold
        if emphasis is None:
            self.emphasis = []
        else:
            self.emphasis = emphasis
        if computeroutput is None:
            self.computeroutput = []
        else:
            self.computeroutput = computeroutput
        if subscript is None:
            self.subscript = []
        else:
            self.subscript = subscript
        if superscript is None:
            self.superscript = []
        else:
            self.superscript = superscript
        if center is None:
            self.center = []
        else:
            self.center = center
        if small is None:
            self.small = []
        else:
            self.small = small
        if htmlonly is None:
            self.htmlonly = []
        else:
            self.htmlonly = htmlonly
        if manonly is None:
            self.manonly = []
        else:
            self.manonly = manonly
        if xmlonly is None:
            self.xmlonly = []
        else:
            self.xmlonly = xmlonly
        if rtfonly is None:
            self.rtfonly = []
        else:
            self.rtfonly = rtfonly
        if latexonly is None:
            self.latexonly = []
        else:
            self.latexonly = latexonly
        if dot is None:
            self.dot = []
        else:
            self.dot = dot
        if plantuml is None:
            self.plantuml = []
        else:
            self.plantuml = plantuml
        if anchor is None:
            self.anchor = []
        else:
            self.anchor = anchor
        if formula is None:
            self.formula = []
        else:
            self.formula = formula
        if ref is None:
            self.ref = []
        else:
            self.ref = ref
        if nonbreakablespace is None:
            self.nonbreakablespace = []
        else:
            self.nonbreakablespace = nonbreakablespace
        if iexcl is None:
            self.iexcl = []
        else:
            self.iexcl = iexcl
        if cent is None:
            self.cent = []
        else:
            self.cent = cent
        if pound is None:
            self.pound = []
        else:
            self.pound = pound
        if curren is None:
            self.curren = []
        else:
            self.curren = curren
        if yen is None:
            self.yen = []
        else:
            self.yen = yen
        if brvbar is None:
            self.brvbar = []
        else:
            self.brvbar = brvbar
        if sect is None:
            self.sect = []
        else:
            self.sect = sect
        if umlaut is None:
            self.umlaut = []
        else:
            self.umlaut = umlaut
        if copy is None:
            self.copy = []
        else:
            self.copy = copy
        if ordf is None:
            self.ordf = []
        else:
            self.ordf = ordf
        if laquo is None:
            self.laquo = []
        else:
            self.laquo = laquo
        if not_ is None:
            self.not_ = []
        else:
            self.not_ = not_
        if shy is None:
            self.shy = []
        else:
            self.shy = shy
        if registered is None:
            self.registered = []
        else:
            self.registered = registered
        if macr is None:
            self.macr = []
        else:
            self.macr = macr
        if deg is None:
            self.deg = []
        else:
            self.deg = deg
        if plusmn is None:
            self.plusmn = []
        else:
            self.plusmn = plusmn
        if sup2 is None:
            self.sup2 = []
        else:
            self.sup2 = sup2
        if sup3 is None:
            self.sup3 = []
        else:
            self.sup3 = sup3
        if acute is None:
            self.acute = []
        else:
            self.acute = acute
        if micro is None:
            self.micro = []
        else:
            self.micro = micro
        if para is None:
            self.para = []
        else:
            self.para = para
        if middot is None:
            self.middot = []
        else:
            self.middot = middot
        if cedil is None:
            self.cedil = []
        else:
            self.cedil = cedil
        if sup1 is None:
            self.sup1 = []
        else:
            self.sup1 = sup1
        if ordm is None:
            self.ordm = []
        else:
            self.ordm = ordm
        if raquo is None:
            self.raquo = []
        else:
            self.raquo = raquo
        if frac14 is None:
            self.frac14 = []
        else:
            self.frac14 = frac14
        if frac12 is None:
            self.frac12 = []
        else:
            self.frac12 = frac12
        if frac34 is None:
            self.frac34 = []
        else:
            self.frac34 = frac34
        if iquest is None:
            self.iquest = []
        else:
            self.iquest = iquest
        if Agrave is None:
            self.Agrave = []
        else:
            self.Agrave = Agrave
        if Aacute is None:
            self.Aacute = []
        else:
            self.Aacute = Aacute
        if Acirc is None:
            self.Acirc = []
        else:
            self.Acirc = Acirc
        if Atilde is None:
            self.Atilde = []
        else:
            self.Atilde = Atilde
        if Aumlaut is None:
            self.Aumlaut = []
        else:
            self.Aumlaut = Aumlaut
        if Aring is None:
            self.Aring = []
        else:
            self.Aring = Aring
        if AElig is None:
            self.AElig = []
        else:
            self.AElig = AElig
        if Ccedil is None:
            self.Ccedil = []
        else:
            self.Ccedil = Ccedil
        if Egrave is None:
            self.Egrave = []
        else:
            self.Egrave = Egrave
        if Eacute is None:
            self.Eacute = []
        else:
            self.Eacute = Eacute
        if Ecirc is None:
            self.Ecirc = []
        else:
            self.Ecirc = Ecirc
        if Eumlaut is None:
            self.Eumlaut = []
        else:
            self.Eumlaut = Eumlaut
        if Igrave is None:
            self.Igrave = []
        else:
            self.Igrave = Igrave
        if Iacute is None:
            self.Iacute = []
        else:
            self.Iacute = Iacute
        if Icirc is None:
            self.Icirc = []
        else:
            self.Icirc = Icirc
        if Iumlaut is None:
            self.Iumlaut = []
        else:
            self.Iumlaut = Iumlaut
        if ETH is None:
            self.ETH = []
        else:
            self.ETH = ETH
        if Ntilde is None:
            self.Ntilde = []
        else:
            self.Ntilde = Ntilde
        if Ograve is None:
            self.Ograve = []
        else:
            self.Ograve = Ograve
        if Oacute is None:
            self.Oacute = []
        else:
            self.Oacute = Oacute
        if Ocirc is None:
            self.Ocirc = []
        else:
            self.Ocirc = Ocirc
        if Otilde is None:
            self.Otilde = []
        else:
            self.Otilde = Otilde
        if Oumlaut is None:
            self.Oumlaut = []
        else:
            self.Oumlaut = Oumlaut
        if times is None:
            self.times = []
        else:
            self.times = times
        if Oslash is None:
            self.Oslash = []
        else:
            self.Oslash = Oslash
        if Ugrave is None:
            self.Ugrave = []
        else:
            self.Ugrave = Ugrave
        if Uacute is None:
            self.Uacute = []
        else:
            self.Uacute = Uacute
        if Ucirc is None:
            self.Ucirc = []
        else:
            self.Ucirc = Ucirc
        if Uumlaut is None:
            self.Uumlaut = []
        else:
            self.Uumlaut = Uumlaut
        if Yacute is None:
            self.Yacute = []
        else:
            self.Yacute = Yacute
        if THORN is None:
            self.THORN = []
        else:
            self.THORN = THORN
        if szlig is None:
            self.szlig = []
        else:
            self.szlig = szlig
        if agrave is None:
            self.agrave = []
        else:
            self.agrave = agrave
        if aacute is None:
            self.aacute = []
        else:
            self.aacute = aacute
        if acirc is None:
            self.acirc = []
        else:
            self.acirc = acirc
        if atilde is None:
            self.atilde = []
        else:
            self.atilde = atilde
        if aumlaut is None:
            self.aumlaut = []
        else:
            self.aumlaut = aumlaut
        if aring is None:
            self.aring = []
        else:
            self.aring = aring
        if aelig is None:
            self.aelig = []
        else:
            self.aelig = aelig
        if ccedil is None:
            self.ccedil = []
        else:
            self.ccedil = ccedil
        if egrave is None:
            self.egrave = []
        else:
            self.egrave = egrave
        if eacute is None:
            self.eacute = []
        else:
            self.eacute = eacute
        if ecirc is None:
            self.ecirc = []
        else:
            self.ecirc = ecirc
        if eumlaut is None:
            self.eumlaut = []
        else:
            self.eumlaut = eumlaut
        if igrave is None:
            self.igrave = []
        else:
            self.igrave = igrave
        if iacute is None:
            self.iacute = []
        else:
            self.iacute = iacute
        if icirc is None:
            self.icirc = []
        else:
            self.icirc = icirc
        if iumlaut is None:
            self.iumlaut = []
        else:
            self.iumlaut = iumlaut
        if eth is None:
            self.eth = []
        else:
            self.eth = eth
        if ntilde is None:
            self.ntilde = []
        else:
            self.ntilde = ntilde
        if ograve is None:
            self.ograve = []
        else:
            self.ograve = ograve
        if oacute is None:
            self.oacute = []
        else:
            self.oacute = oacute
        if ocirc is None:
            self.ocirc = []
        else:
            self.ocirc = ocirc
        if otilde is None:
            self.otilde = []
        else:
            self.otilde = otilde
        if oumlaut is None:
            self.oumlaut = []
        else:
            self.oumlaut = oumlaut
        if divide is None:
            self.divide = []
        else:
            self.divide = divide
        if oslash is None:
            self.oslash = []
        else:
            self.oslash = oslash
        if ugrave is None:
            self.ugrave = []
        else:
            self.ugrave = ugrave
        if uacute is None:
            self.uacute = []
        else:
            self.uacute = uacute
        if ucirc is None:
            self.ucirc = []
        else:
            self.ucirc = ucirc
        if uumlaut is None:
            self.uumlaut = []
        else:
            self.uumlaut = uumlaut
        if yacute is None:
            self.yacute = []
        else:
            self.yacute = yacute
        if thorn is None:
            self.thorn = []
        else:
            self.thorn = thorn
        if yumlaut is None:
            self.yumlaut = []
        else:
            self.yumlaut = yumlaut
        if fnof is None:
            self.fnof = []
        else:
            self.fnof = fnof
        if Alpha is None:
            self.Alpha = []
        else:
            self.Alpha = Alpha
        if Beta is None:
            self.Beta = []
        else:
            self.Beta = Beta
        if Gamma is None:
            self.Gamma = []
        else:
            self.Gamma = Gamma
        if Delta is None:
            self.Delta = []
        else:
            self.Delta = Delta
        if Epsilon is None:
            self.Epsilon = []
        else:
            self.Epsilon = Epsilon
        if Zeta is None:
            self.Zeta = []
        else:
            self.Zeta = Zeta
        if Eta is None:
            self.Eta = []
        else:
            self.Eta = Eta
        if Theta is None:
            self.Theta = []
        else:
            self.Theta = Theta
        if Iota is None:
            self.Iota = []
        else:
            self.Iota = Iota
        if Kappa is None:
            self.Kappa = []
        else:
            self.Kappa = Kappa
        if Lambda is None:
            self.Lambda = []
        else:
            self.Lambda = Lambda
        if Mu is None:
            self.Mu = []
        else:
            self.Mu = Mu
        if Nu is None:
            self.Nu = []
        else:
            self.Nu = Nu
        if Xi is None:
            self.Xi = []
        else:
            self.Xi = Xi
        if Omicron is None:
            self.Omicron = []
        else:
            self.Omicron = Omicron
        if Pi is None:
            self.Pi = []
        else:
            self.Pi = Pi
        if Rho is None:
            self.Rho = []
        else:
            self.Rho = Rho
        if Sigma is None:
            self.Sigma = []
        else:
            self.Sigma = Sigma
        if Tau is None:
            self.Tau = []
        else:
            self.Tau = Tau
        if Upsilon is None:
            self.Upsilon = []
        else:
            self.Upsilon = Upsilon
        if Phi is None:
            self.Phi = []
        else:
            self.Phi = Phi
        if Chi is None:
            self.Chi = []
        else:
            self.Chi = Chi
        if Psi is None:
            self.Psi = []
        else:
            self.Psi = Psi
        if Omega is None:
            self.Omega = []
        else:
            self.Omega = Omega
        if alpha is None:
            self.alpha = []
        else:
            self.alpha = alpha
        if beta is None:
            self.beta = []
        else:
            self.beta = beta
        if gamma is None:
            self.gamma = []
        else:
            self.gamma = gamma
        if delta is None:
            self.delta = []
        else:
            self.delta = delta
        if epsilon is None:
            self.epsilon = []
        else:
            self.epsilon = epsilon
        if zeta is None:
            self.zeta = []
        else:
            self.zeta = zeta
        if eta is None:
            self.eta = []
        else:
            self.eta = eta
        if theta is None:
            self.theta = []
        else:
            self.theta = theta
        if iota is None:
            self.iota = []
        else:
            self.iota = iota
        if kappa is None:
            self.kappa = []
        else:
            self.kappa = kappa
        if lambda_ is None:
            self.lambda_ = []
        else:
            self.lambda_ = lambda_
        if mu is None:
            self.mu = []
        else:
            self.mu = mu
        if nu is None:
            self.nu = []
        else:
            self.nu = nu
        if xi is None:
            self.xi = []
        else:
            self.xi = xi
        if omicron is None:
            self.omicron = []
        else:
            self.omicron = omicron
        if pi is None:
            self.pi = []
        else:
            self.pi = pi
        if rho is None:
            self.rho = []
        else:
            self.rho = rho
        if sigmaf is None:
            self.sigmaf = []
        else:
            self.sigmaf = sigmaf
        if sigma is None:
            self.sigma = []
        else:
            self.sigma = sigma
        if tau is None:
            self.tau = []
        else:
            self.tau = tau
        if upsilon is None:
            self.upsilon = []
        else:
            self.upsilon = upsilon
        if phi is None:
            self.phi = []
        else:
            self.phi = phi
        if chi is None:
            self.chi = []
        else:
            self.chi = chi
        if psi is None:
            self.psi = []
        else:
            self.psi = psi
        if omega is None:
            self.omega = []
        else:
            self.omega = omega
        if thetasym is None:
            self.thetasym = []
        else:
            self.thetasym = thetasym
        if upsih is None:
            self.upsih = []
        else:
            self.upsih = upsih
        if piv is None:
            self.piv = []
        else:
            self.piv = piv
        if bull is None:
            self.bull = []
        else:
            self.bull = bull
        if hellip is None:
            self.hellip = []
        else:
            self.hellip = hellip
        if prime is None:
            self.prime = []
        else:
            self.prime = prime
        if Prime is None:
            self.Prime = []
        else:
            self.Prime = Prime
        if oline is None:
            self.oline = []
        else:
            self.oline = oline
        if frasl is None:
            self.frasl = []
        else:
            self.frasl = frasl
        if weierp is None:
            self.weierp = []
        else:
            self.weierp = weierp
        if imaginary is None:
            self.imaginary = []
        else:
            self.imaginary = imaginary
        if real is None:
            self.real = []
        else:
            self.real = real
        if trademark is None:
            self.trademark = []
        else:
            self.trademark = trademark
        if alefsym is None:
            self.alefsym = []
        else:
            self.alefsym = alefsym
        if larr is None:
            self.larr = []
        else:
            self.larr = larr
        if uarr is None:
            self.uarr = []
        else:
            self.uarr = uarr
        if rarr is None:
            self.rarr = []
        else:
            self.rarr = rarr
        if darr is None:
            self.darr = []
        else:
            self.darr = darr
        if harr is None:
            self.harr = []
        else:
            self.harr = harr
        if crarr is None:
            self.crarr = []
        else:
            self.crarr = crarr
        if lArr is None:
            self.lArr = []
        else:
            self.lArr = lArr
        if uArr is None:
            self.uArr = []
        else:
            self.uArr = uArr
        if rArr is None:
            self.rArr = []
        else:
            self.rArr = rArr
        if dArr is None:
            self.dArr = []
        else:
            self.dArr = dArr
        if hArr is None:
            self.hArr = []
        else:
            self.hArr = hArr
        if forall is None:
            self.forall = []
        else:
            self.forall = forall
        if part is None:
            self.part = []
        else:
            self.part = part
        if exist is None:
            self.exist = []
        else:
            self.exist = exist
        if empty is None:
            self.empty = []
        else:
            self.empty = empty
        if nabla is None:
            self.nabla = []
        else:
            self.nabla = nabla
        if isin is None:
            self.isin = []
        else:
            self.isin = isin
        if notin is None:
            self.notin = []
        else:
            self.notin = notin
        if ni is None:
            self.ni = []
        else:
            self.ni = ni
        if prod is None:
            self.prod = []
        else:
            self.prod = prod
        if sum is None:
            self.sum = []
        else:
            self.sum = sum
        if minus is None:
            self.minus = []
        else:
            self.minus = minus
        if lowast is None:
            self.lowast = []
        else:
            self.lowast = lowast
        if radic is None:
            self.radic = []
        else:
            self.radic = radic
        if prop is None:
            self.prop = []
        else:
            self.prop = prop
        if infin is None:
            self.infin = []
        else:
            self.infin = infin
        if ang is None:
            self.ang = []
        else:
            self.ang = ang
        if and_ is None:
            self.and_ = []
        else:
            self.and_ = and_
        if or_ is None:
            self.or_ = []
        else:
            self.or_ = or_
        if cap is None:
            self.cap = []
        else:
            self.cap = cap
        if cup is None:
            self.cup = []
        else:
            self.cup = cup
        if int is None:
            self.int = []
        else:
            self.int = int
        if there4 is None:
            self.there4 = []
        else:
            self.there4 = there4
        if sim is None:
            self.sim = []
        else:
            self.sim = sim
        if cong is None:
            self.cong = []
        else:
            self.cong = cong
        if asymp is None:
            self.asymp = []
        else:
            self.asymp = asymp
        if ne is None:
            self.ne = []
        else:
            self.ne = ne
        if equiv is None:
            self.equiv = []
        else:
            self.equiv = equiv
        if le is None:
            self.le = []
        else:
            self.le = le
        if ge is None:
            self.ge = []
        else:
            self.ge = ge
        if sub is None:
            self.sub = []
        else:
            self.sub = sub
        if sup is None:
            self.sup = []
        else:
            self.sup = sup
        if nsub is None:
            self.nsub = []
        else:
            self.nsub = nsub
        if sube is None:
            self.sube = []
        else:
            self.sube = sube
        if supe is None:
            self.supe = []
        else:
            self.supe = supe
        if oplus is None:
            self.oplus = []
        else:
            self.oplus = oplus
        if otimes is None:
            self.otimes = []
        else:
            self.otimes = otimes
        if perp is None:
            self.perp = []
        else:
            self.perp = perp
        if sdot is None:
            self.sdot = []
        else:
            self.sdot = sdot
        if lceil is None:
            self.lceil = []
        else:
            self.lceil = lceil
        if rceil is None:
            self.rceil = []
        else:
            self.rceil = rceil
        if lfloor is None:
            self.lfloor = []
        else:
            self.lfloor = lfloor
        if rfloor is None:
            self.rfloor = []
        else:
            self.rfloor = rfloor
        if lang is None:
            self.lang = []
        else:
            self.lang = lang
        if rang is None:
            self.rang = []
        else:
            self.rang = rang
        if loz is None:
            self.loz = []
        else:
            self.loz = loz
        if spades is None:
            self.spades = []
        else:
            self.spades = spades
        if clubs is None:
            self.clubs = []
        else:
            self.clubs = clubs
        if hearts is None:
            self.hearts = []
        else:
            self.hearts = hearts
        if diams is None:
            self.diams = []
        else:
            self.diams = diams
        if OElig is None:
            self.OElig = []
        else:
            self.OElig = OElig
        if oelig is None:
            self.oelig = []
        else:
            self.oelig = oelig
        if Scaron is None:
            self.Scaron = []
        else:
            self.Scaron = Scaron
        if scaron is None:
            self.scaron = []
        else:
            self.scaron = scaron
        if Yumlaut is None:
            self.Yumlaut = []
        else:
            self.Yumlaut = Yumlaut
        if circ is None:
            self.circ = []
        else:
            self.circ = circ
        if tilde is None:
            self.tilde = []
        else:
            self.tilde = tilde
        if ensp is None:
            self.ensp = []
        else:
            self.ensp = ensp
        if emsp is None:
            self.emsp = []
        else:
            self.emsp = emsp
        if thinsp is None:
            self.thinsp = []
        else:
            self.thinsp = thinsp
        if zwnj is None:
            self.zwnj = []
        else:
            self.zwnj = zwnj
        if zwj is None:
            self.zwj = []
        else:
            self.zwj = zwj
        if lrm is None:
            self.lrm = []
        else:
            self.lrm = lrm
        if rlm is None:
            self.rlm = []
        else:
            self.rlm = rlm
        if ndash is None:
            self.ndash = []
        else:
            self.ndash = ndash
        if mdash is None:
            self.mdash = []
        else:
            self.mdash = mdash
        if lsquo is None:
            self.lsquo = []
        else:
            self.lsquo = lsquo
        if rsquo is None:
            self.rsquo = []
        else:
            self.rsquo = rsquo
        if sbquo is None:
            self.sbquo = []
        else:
            self.sbquo = sbquo
        if ldquo is None:
            self.ldquo = []
        else:
            self.ldquo = ldquo
        if rdquo is None:
            self.rdquo = []
        else:
            self.rdquo = rdquo
        if bdquo is None:
            self.bdquo = []
        else:
            self.bdquo = bdquo
        if dagger is None:
            self.dagger = []
        else:
            self.dagger = dagger
        if Dagger is None:
            self.Dagger = []
        else:
            self.Dagger = Dagger
        if permil is None:
            self.permil = []
        else:
            self.permil = permil
        if lsaquo is None:
            self.lsaquo = []
        else:
            self.lsaquo = lsaquo
        if rsaquo is None:
            self.rsaquo = []
        else:
            self.rsaquo = rsaquo
        if euro is None:
            self.euro = []
        else:
            self.euro = euro
        if tm is None:
            self.tm = []
        else:
            self.tm = tm
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docTocItemType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docTocItemType.subclass:
            return docTocItemType.subclass(*args_, **kwargs_)
        else:
            return docTocItemType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ulink(self): return self.ulink
    def set_ulink(self, ulink): self.ulink = ulink
    def add_ulink(self, value): self.ulink.append(value)
    def insert_ulink_at(self, index, value): self.ulink.insert(index, value)
    def replace_ulink_at(self, index, value): self.ulink[index] = value
    def get_bold(self): return self.bold
    def set_bold(self, bold): self.bold = bold
    def add_bold(self, value): self.bold.append(value)
    def insert_bold_at(self, index, value): self.bold.insert(index, value)
    def replace_bold_at(self, index, value): self.bold[index] = value
    def get_emphasis(self): return self.emphasis
    def set_emphasis(self, emphasis): self.emphasis = emphasis
    def add_emphasis(self, value): self.emphasis.append(value)
    def insert_emphasis_at(self, index, value): self.emphasis.insert(index, value)
    def replace_emphasis_at(self, index, value): self.emphasis[index] = value
    def get_computeroutput(self): return self.computeroutput
    def set_computeroutput(self, computeroutput): self.computeroutput = computeroutput
    def add_computeroutput(self, value): self.computeroutput.append(value)
    def insert_computeroutput_at(self, index, value): self.computeroutput.insert(index, value)
    def replace_computeroutput_at(self, index, value): self.computeroutput[index] = value
    def get_subscript(self): return self.subscript
    def set_subscript(self, subscript): self.subscript = subscript
    def add_subscript(self, value): self.subscript.append(value)
    def insert_subscript_at(self, index, value): self.subscript.insert(index, value)
    def replace_subscript_at(self, index, value): self.subscript[index] = value
    def get_superscript(self): return self.superscript
    def set_superscript(self, superscript): self.superscript = superscript
    def add_superscript(self, value): self.superscript.append(value)
    def insert_superscript_at(self, index, value): self.superscript.insert(index, value)
    def replace_superscript_at(self, index, value): self.superscript[index] = value
    def get_center(self): return self.center
    def set_center(self, center): self.center = center
    def add_center(self, value): self.center.append(value)
    def insert_center_at(self, index, value): self.center.insert(index, value)
    def replace_center_at(self, index, value): self.center[index] = value
    def get_small(self): return self.small
    def set_small(self, small): self.small = small
    def add_small(self, value): self.small.append(value)
    def insert_small_at(self, index, value): self.small.insert(index, value)
    def replace_small_at(self, index, value): self.small[index] = value
    def get_htmlonly(self): return self.htmlonly
    def set_htmlonly(self, htmlonly): self.htmlonly = htmlonly
    def add_htmlonly(self, value): self.htmlonly.append(value)
    def insert_htmlonly_at(self, index, value): self.htmlonly.insert(index, value)
    def replace_htmlonly_at(self, index, value): self.htmlonly[index] = value
    def get_manonly(self): return self.manonly
    def set_manonly(self, manonly): self.manonly = manonly
    def add_manonly(self, value): self.manonly.append(value)
    def insert_manonly_at(self, index, value): self.manonly.insert(index, value)
    def replace_manonly_at(self, index, value): self.manonly[index] = value
    def get_xmlonly(self): return self.xmlonly
    def set_xmlonly(self, xmlonly): self.xmlonly = xmlonly
    def add_xmlonly(self, value): self.xmlonly.append(value)
    def insert_xmlonly_at(self, index, value): self.xmlonly.insert(index, value)
    def replace_xmlonly_at(self, index, value): self.xmlonly[index] = value
    def get_rtfonly(self): return self.rtfonly
    def set_rtfonly(self, rtfonly): self.rtfonly = rtfonly
    def add_rtfonly(self, value): self.rtfonly.append(value)
    def insert_rtfonly_at(self, index, value): self.rtfonly.insert(index, value)
    def replace_rtfonly_at(self, index, value): self.rtfonly[index] = value
    def get_latexonly(self): return self.latexonly
    def set_latexonly(self, latexonly): self.latexonly = latexonly
    def add_latexonly(self, value): self.latexonly.append(value)
    def insert_latexonly_at(self, index, value): self.latexonly.insert(index, value)
    def replace_latexonly_at(self, index, value): self.latexonly[index] = value
    def get_dot(self): return self.dot
    def set_dot(self, dot): self.dot = dot
    def add_dot(self, value): self.dot.append(value)
    def insert_dot_at(self, index, value): self.dot.insert(index, value)
    def replace_dot_at(self, index, value): self.dot[index] = value
    def get_plantuml(self): return self.plantuml
    def set_plantuml(self, plantuml): self.plantuml = plantuml
    def add_plantuml(self, value): self.plantuml.append(value)
    def insert_plantuml_at(self, index, value): self.plantuml.insert(index, value)
    def replace_plantuml_at(self, index, value): self.plantuml[index] = value
    def get_anchor(self): return self.anchor
    def set_anchor(self, anchor): self.anchor = anchor
    def add_anchor(self, value): self.anchor.append(value)
    def insert_anchor_at(self, index, value): self.anchor.insert(index, value)
    def replace_anchor_at(self, index, value): self.anchor[index] = value
    def get_formula(self): return self.formula
    def set_formula(self, formula): self.formula = formula
    def add_formula(self, value): self.formula.append(value)
    def insert_formula_at(self, index, value): self.formula.insert(index, value)
    def replace_formula_at(self, index, value): self.formula[index] = value
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def add_ref(self, value): self.ref.append(value)
    def insert_ref_at(self, index, value): self.ref.insert(index, value)
    def replace_ref_at(self, index, value): self.ref[index] = value
    def get_nonbreakablespace(self): return self.nonbreakablespace
    def set_nonbreakablespace(self, nonbreakablespace): self.nonbreakablespace = nonbreakablespace
    def add_nonbreakablespace(self, value): self.nonbreakablespace.append(value)
    def insert_nonbreakablespace_at(self, index, value): self.nonbreakablespace.insert(index, value)
    def replace_nonbreakablespace_at(self, index, value): self.nonbreakablespace[index] = value
    def get_iexcl(self): return self.iexcl
    def set_iexcl(self, iexcl): self.iexcl = iexcl
    def add_iexcl(self, value): self.iexcl.append(value)
    def insert_iexcl_at(self, index, value): self.iexcl.insert(index, value)
    def replace_iexcl_at(self, index, value): self.iexcl[index] = value
    def get_cent(self): return self.cent
    def set_cent(self, cent): self.cent = cent
    def add_cent(self, value): self.cent.append(value)
    def insert_cent_at(self, index, value): self.cent.insert(index, value)
    def replace_cent_at(self, index, value): self.cent[index] = value
    def get_pound(self): return self.pound
    def set_pound(self, pound): self.pound = pound
    def add_pound(self, value): self.pound.append(value)
    def insert_pound_at(self, index, value): self.pound.insert(index, value)
    def replace_pound_at(self, index, value): self.pound[index] = value
    def get_curren(self): return self.curren
    def set_curren(self, curren): self.curren = curren
    def add_curren(self, value): self.curren.append(value)
    def insert_curren_at(self, index, value): self.curren.insert(index, value)
    def replace_curren_at(self, index, value): self.curren[index] = value
    def get_yen(self): return self.yen
    def set_yen(self, yen): self.yen = yen
    def add_yen(self, value): self.yen.append(value)
    def insert_yen_at(self, index, value): self.yen.insert(index, value)
    def replace_yen_at(self, index, value): self.yen[index] = value
    def get_brvbar(self): return self.brvbar
    def set_brvbar(self, brvbar): self.brvbar = brvbar
    def add_brvbar(self, value): self.brvbar.append(value)
    def insert_brvbar_at(self, index, value): self.brvbar.insert(index, value)
    def replace_brvbar_at(self, index, value): self.brvbar[index] = value
    def get_sect(self): return self.sect
    def set_sect(self, sect): self.sect = sect
    def add_sect(self, value): self.sect.append(value)
    def insert_sect_at(self, index, value): self.sect.insert(index, value)
    def replace_sect_at(self, index, value): self.sect[index] = value
    def get_umlaut(self): return self.umlaut
    def set_umlaut(self, umlaut): self.umlaut = umlaut
    def add_umlaut(self, value): self.umlaut.append(value)
    def insert_umlaut_at(self, index, value): self.umlaut.insert(index, value)
    def replace_umlaut_at(self, index, value): self.umlaut[index] = value
    def get_copy(self): return self.copy
    def set_copy(self, copy): self.copy = copy
    def add_copy(self, value): self.copy.append(value)
    def insert_copy_at(self, index, value): self.copy.insert(index, value)
    def replace_copy_at(self, index, value): self.copy[index] = value
    def get_ordf(self): return self.ordf
    def set_ordf(self, ordf): self.ordf = ordf
    def add_ordf(self, value): self.ordf.append(value)
    def insert_ordf_at(self, index, value): self.ordf.insert(index, value)
    def replace_ordf_at(self, index, value): self.ordf[index] = value
    def get_laquo(self): return self.laquo
    def set_laquo(self, laquo): self.laquo = laquo
    def add_laquo(self, value): self.laquo.append(value)
    def insert_laquo_at(self, index, value): self.laquo.insert(index, value)
    def replace_laquo_at(self, index, value): self.laquo[index] = value
    def get_not(self): return self.not_
    def set_not(self, not_): self.not_ = not_
    def add_not(self, value): self.not_.append(value)
    def insert_not_at(self, index, value): self.not_.insert(index, value)
    def replace_not_at(self, index, value): self.not_[index] = value
    def get_shy(self): return self.shy
    def set_shy(self, shy): self.shy = shy
    def add_shy(self, value): self.shy.append(value)
    def insert_shy_at(self, index, value): self.shy.insert(index, value)
    def replace_shy_at(self, index, value): self.shy[index] = value
    def get_registered(self): return self.registered
    def set_registered(self, registered): self.registered = registered
    def add_registered(self, value): self.registered.append(value)
    def insert_registered_at(self, index, value): self.registered.insert(index, value)
    def replace_registered_at(self, index, value): self.registered[index] = value
    def get_macr(self): return self.macr
    def set_macr(self, macr): self.macr = macr
    def add_macr(self, value): self.macr.append(value)
    def insert_macr_at(self, index, value): self.macr.insert(index, value)
    def replace_macr_at(self, index, value): self.macr[index] = value
    def get_deg(self): return self.deg
    def set_deg(self, deg): self.deg = deg
    def add_deg(self, value): self.deg.append(value)
    def insert_deg_at(self, index, value): self.deg.insert(index, value)
    def replace_deg_at(self, index, value): self.deg[index] = value
    def get_plusmn(self): return self.plusmn
    def set_plusmn(self, plusmn): self.plusmn = plusmn
    def add_plusmn(self, value): self.plusmn.append(value)
    def insert_plusmn_at(self, index, value): self.plusmn.insert(index, value)
    def replace_plusmn_at(self, index, value): self.plusmn[index] = value
    def get_sup2(self): return self.sup2
    def set_sup2(self, sup2): self.sup2 = sup2
    def add_sup2(self, value): self.sup2.append(value)
    def insert_sup2_at(self, index, value): self.sup2.insert(index, value)
    def replace_sup2_at(self, index, value): self.sup2[index] = value
    def get_sup3(self): return self.sup3
    def set_sup3(self, sup3): self.sup3 = sup3
    def add_sup3(self, value): self.sup3.append(value)
    def insert_sup3_at(self, index, value): self.sup3.insert(index, value)
    def replace_sup3_at(self, index, value): self.sup3[index] = value
    def get_acute(self): return self.acute
    def set_acute(self, acute): self.acute = acute
    def add_acute(self, value): self.acute.append(value)
    def insert_acute_at(self, index, value): self.acute.insert(index, value)
    def replace_acute_at(self, index, value): self.acute[index] = value
    def get_micro(self): return self.micro
    def set_micro(self, micro): self.micro = micro
    def add_micro(self, value): self.micro.append(value)
    def insert_micro_at(self, index, value): self.micro.insert(index, value)
    def replace_micro_at(self, index, value): self.micro[index] = value
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_middot(self): return self.middot
    def set_middot(self, middot): self.middot = middot
    def add_middot(self, value): self.middot.append(value)
    def insert_middot_at(self, index, value): self.middot.insert(index, value)
    def replace_middot_at(self, index, value): self.middot[index] = value
    def get_cedil(self): return self.cedil
    def set_cedil(self, cedil): self.cedil = cedil
    def add_cedil(self, value): self.cedil.append(value)
    def insert_cedil_at(self, index, value): self.cedil.insert(index, value)
    def replace_cedil_at(self, index, value): self.cedil[index] = value
    def get_sup1(self): return self.sup1
    def set_sup1(self, sup1): self.sup1 = sup1
    def add_sup1(self, value): self.sup1.append(value)
    def insert_sup1_at(self, index, value): self.sup1.insert(index, value)
    def replace_sup1_at(self, index, value): self.sup1[index] = value
    def get_ordm(self): return self.ordm
    def set_ordm(self, ordm): self.ordm = ordm
    def add_ordm(self, value): self.ordm.append(value)
    def insert_ordm_at(self, index, value): self.ordm.insert(index, value)
    def replace_ordm_at(self, index, value): self.ordm[index] = value
    def get_raquo(self): return self.raquo
    def set_raquo(self, raquo): self.raquo = raquo
    def add_raquo(self, value): self.raquo.append(value)
    def insert_raquo_at(self, index, value): self.raquo.insert(index, value)
    def replace_raquo_at(self, index, value): self.raquo[index] = value
    def get_frac14(self): return self.frac14
    def set_frac14(self, frac14): self.frac14 = frac14
    def add_frac14(self, value): self.frac14.append(value)
    def insert_frac14_at(self, index, value): self.frac14.insert(index, value)
    def replace_frac14_at(self, index, value): self.frac14[index] = value
    def get_frac12(self): return self.frac12
    def set_frac12(self, frac12): self.frac12 = frac12
    def add_frac12(self, value): self.frac12.append(value)
    def insert_frac12_at(self, index, value): self.frac12.insert(index, value)
    def replace_frac12_at(self, index, value): self.frac12[index] = value
    def get_frac34(self): return self.frac34
    def set_frac34(self, frac34): self.frac34 = frac34
    def add_frac34(self, value): self.frac34.append(value)
    def insert_frac34_at(self, index, value): self.frac34.insert(index, value)
    def replace_frac34_at(self, index, value): self.frac34[index] = value
    def get_iquest(self): return self.iquest
    def set_iquest(self, iquest): self.iquest = iquest
    def add_iquest(self, value): self.iquest.append(value)
    def insert_iquest_at(self, index, value): self.iquest.insert(index, value)
    def replace_iquest_at(self, index, value): self.iquest[index] = value
    def get_Agrave(self): return self.Agrave
    def set_Agrave(self, Agrave): self.Agrave = Agrave
    def add_Agrave(self, value): self.Agrave.append(value)
    def insert_Agrave_at(self, index, value): self.Agrave.insert(index, value)
    def replace_Agrave_at(self, index, value): self.Agrave[index] = value
    def get_Aacute(self): return self.Aacute
    def set_Aacute(self, Aacute): self.Aacute = Aacute
    def add_Aacute(self, value): self.Aacute.append(value)
    def insert_Aacute_at(self, index, value): self.Aacute.insert(index, value)
    def replace_Aacute_at(self, index, value): self.Aacute[index] = value
    def get_Acirc(self): return self.Acirc
    def set_Acirc(self, Acirc): self.Acirc = Acirc
    def add_Acirc(self, value): self.Acirc.append(value)
    def insert_Acirc_at(self, index, value): self.Acirc.insert(index, value)
    def replace_Acirc_at(self, index, value): self.Acirc[index] = value
    def get_Atilde(self): return self.Atilde
    def set_Atilde(self, Atilde): self.Atilde = Atilde
    def add_Atilde(self, value): self.Atilde.append(value)
    def insert_Atilde_at(self, index, value): self.Atilde.insert(index, value)
    def replace_Atilde_at(self, index, value): self.Atilde[index] = value
    def get_Aumlaut(self): return self.Aumlaut
    def set_Aumlaut(self, Aumlaut): self.Aumlaut = Aumlaut
    def add_Aumlaut(self, value): self.Aumlaut.append(value)
    def insert_Aumlaut_at(self, index, value): self.Aumlaut.insert(index, value)
    def replace_Aumlaut_at(self, index, value): self.Aumlaut[index] = value
    def get_Aring(self): return self.Aring
    def set_Aring(self, Aring): self.Aring = Aring
    def add_Aring(self, value): self.Aring.append(value)
    def insert_Aring_at(self, index, value): self.Aring.insert(index, value)
    def replace_Aring_at(self, index, value): self.Aring[index] = value
    def get_AElig(self): return self.AElig
    def set_AElig(self, AElig): self.AElig = AElig
    def add_AElig(self, value): self.AElig.append(value)
    def insert_AElig_at(self, index, value): self.AElig.insert(index, value)
    def replace_AElig_at(self, index, value): self.AElig[index] = value
    def get_Ccedil(self): return self.Ccedil
    def set_Ccedil(self, Ccedil): self.Ccedil = Ccedil
    def add_Ccedil(self, value): self.Ccedil.append(value)
    def insert_Ccedil_at(self, index, value): self.Ccedil.insert(index, value)
    def replace_Ccedil_at(self, index, value): self.Ccedil[index] = value
    def get_Egrave(self): return self.Egrave
    def set_Egrave(self, Egrave): self.Egrave = Egrave
    def add_Egrave(self, value): self.Egrave.append(value)
    def insert_Egrave_at(self, index, value): self.Egrave.insert(index, value)
    def replace_Egrave_at(self, index, value): self.Egrave[index] = value
    def get_Eacute(self): return self.Eacute
    def set_Eacute(self, Eacute): self.Eacute = Eacute
    def add_Eacute(self, value): self.Eacute.append(value)
    def insert_Eacute_at(self, index, value): self.Eacute.insert(index, value)
    def replace_Eacute_at(self, index, value): self.Eacute[index] = value
    def get_Ecirc(self): return self.Ecirc
    def set_Ecirc(self, Ecirc): self.Ecirc = Ecirc
    def add_Ecirc(self, value): self.Ecirc.append(value)
    def insert_Ecirc_at(self, index, value): self.Ecirc.insert(index, value)
    def replace_Ecirc_at(self, index, value): self.Ecirc[index] = value
    def get_Eumlaut(self): return self.Eumlaut
    def set_Eumlaut(self, Eumlaut): self.Eumlaut = Eumlaut
    def add_Eumlaut(self, value): self.Eumlaut.append(value)
    def insert_Eumlaut_at(self, index, value): self.Eumlaut.insert(index, value)
    def replace_Eumlaut_at(self, index, value): self.Eumlaut[index] = value
    def get_Igrave(self): return self.Igrave
    def set_Igrave(self, Igrave): self.Igrave = Igrave
    def add_Igrave(self, value): self.Igrave.append(value)
    def insert_Igrave_at(self, index, value): self.Igrave.insert(index, value)
    def replace_Igrave_at(self, index, value): self.Igrave[index] = value
    def get_Iacute(self): return self.Iacute
    def set_Iacute(self, Iacute): self.Iacute = Iacute
    def add_Iacute(self, value): self.Iacute.append(value)
    def insert_Iacute_at(self, index, value): self.Iacute.insert(index, value)
    def replace_Iacute_at(self, index, value): self.Iacute[index] = value
    def get_Icirc(self): return self.Icirc
    def set_Icirc(self, Icirc): self.Icirc = Icirc
    def add_Icirc(self, value): self.Icirc.append(value)
    def insert_Icirc_at(self, index, value): self.Icirc.insert(index, value)
    def replace_Icirc_at(self, index, value): self.Icirc[index] = value
    def get_Iumlaut(self): return self.Iumlaut
    def set_Iumlaut(self, Iumlaut): self.Iumlaut = Iumlaut
    def add_Iumlaut(self, value): self.Iumlaut.append(value)
    def insert_Iumlaut_at(self, index, value): self.Iumlaut.insert(index, value)
    def replace_Iumlaut_at(self, index, value): self.Iumlaut[index] = value
    def get_ETH(self): return self.ETH
    def set_ETH(self, ETH): self.ETH = ETH
    def add_ETH(self, value): self.ETH.append(value)
    def insert_ETH_at(self, index, value): self.ETH.insert(index, value)
    def replace_ETH_at(self, index, value): self.ETH[index] = value
    def get_Ntilde(self): return self.Ntilde
    def set_Ntilde(self, Ntilde): self.Ntilde = Ntilde
    def add_Ntilde(self, value): self.Ntilde.append(value)
    def insert_Ntilde_at(self, index, value): self.Ntilde.insert(index, value)
    def replace_Ntilde_at(self, index, value): self.Ntilde[index] = value
    def get_Ograve(self): return self.Ograve
    def set_Ograve(self, Ograve): self.Ograve = Ograve
    def add_Ograve(self, value): self.Ograve.append(value)
    def insert_Ograve_at(self, index, value): self.Ograve.insert(index, value)
    def replace_Ograve_at(self, index, value): self.Ograve[index] = value
    def get_Oacute(self): return self.Oacute
    def set_Oacute(self, Oacute): self.Oacute = Oacute
    def add_Oacute(self, value): self.Oacute.append(value)
    def insert_Oacute_at(self, index, value): self.Oacute.insert(index, value)
    def replace_Oacute_at(self, index, value): self.Oacute[index] = value
    def get_Ocirc(self): return self.Ocirc
    def set_Ocirc(self, Ocirc): self.Ocirc = Ocirc
    def add_Ocirc(self, value): self.Ocirc.append(value)
    def insert_Ocirc_at(self, index, value): self.Ocirc.insert(index, value)
    def replace_Ocirc_at(self, index, value): self.Ocirc[index] = value
    def get_Otilde(self): return self.Otilde
    def set_Otilde(self, Otilde): self.Otilde = Otilde
    def add_Otilde(self, value): self.Otilde.append(value)
    def insert_Otilde_at(self, index, value): self.Otilde.insert(index, value)
    def replace_Otilde_at(self, index, value): self.Otilde[index] = value
    def get_Oumlaut(self): return self.Oumlaut
    def set_Oumlaut(self, Oumlaut): self.Oumlaut = Oumlaut
    def add_Oumlaut(self, value): self.Oumlaut.append(value)
    def insert_Oumlaut_at(self, index, value): self.Oumlaut.insert(index, value)
    def replace_Oumlaut_at(self, index, value): self.Oumlaut[index] = value
    def get_times(self): return self.times
    def set_times(self, times): self.times = times
    def add_times(self, value): self.times.append(value)
    def insert_times_at(self, index, value): self.times.insert(index, value)
    def replace_times_at(self, index, value): self.times[index] = value
    def get_Oslash(self): return self.Oslash
    def set_Oslash(self, Oslash): self.Oslash = Oslash
    def add_Oslash(self, value): self.Oslash.append(value)
    def insert_Oslash_at(self, index, value): self.Oslash.insert(index, value)
    def replace_Oslash_at(self, index, value): self.Oslash[index] = value
    def get_Ugrave(self): return self.Ugrave
    def set_Ugrave(self, Ugrave): self.Ugrave = Ugrave
    def add_Ugrave(self, value): self.Ugrave.append(value)
    def insert_Ugrave_at(self, index, value): self.Ugrave.insert(index, value)
    def replace_Ugrave_at(self, index, value): self.Ugrave[index] = value
    def get_Uacute(self): return self.Uacute
    def set_Uacute(self, Uacute): self.Uacute = Uacute
    def add_Uacute(self, value): self.Uacute.append(value)
    def insert_Uacute_at(self, index, value): self.Uacute.insert(index, value)
    def replace_Uacute_at(self, index, value): self.Uacute[index] = value
    def get_Ucirc(self): return self.Ucirc
    def set_Ucirc(self, Ucirc): self.Ucirc = Ucirc
    def add_Ucirc(self, value): self.Ucirc.append(value)
    def insert_Ucirc_at(self, index, value): self.Ucirc.insert(index, value)
    def replace_Ucirc_at(self, index, value): self.Ucirc[index] = value
    def get_Uumlaut(self): return self.Uumlaut
    def set_Uumlaut(self, Uumlaut): self.Uumlaut = Uumlaut
    def add_Uumlaut(self, value): self.Uumlaut.append(value)
    def insert_Uumlaut_at(self, index, value): self.Uumlaut.insert(index, value)
    def replace_Uumlaut_at(self, index, value): self.Uumlaut[index] = value
    def get_Yacute(self): return self.Yacute
    def set_Yacute(self, Yacute): self.Yacute = Yacute
    def add_Yacute(self, value): self.Yacute.append(value)
    def insert_Yacute_at(self, index, value): self.Yacute.insert(index, value)
    def replace_Yacute_at(self, index, value): self.Yacute[index] = value
    def get_THORN(self): return self.THORN
    def set_THORN(self, THORN): self.THORN = THORN
    def add_THORN(self, value): self.THORN.append(value)
    def insert_THORN_at(self, index, value): self.THORN.insert(index, value)
    def replace_THORN_at(self, index, value): self.THORN[index] = value
    def get_szlig(self): return self.szlig
    def set_szlig(self, szlig): self.szlig = szlig
    def add_szlig(self, value): self.szlig.append(value)
    def insert_szlig_at(self, index, value): self.szlig.insert(index, value)
    def replace_szlig_at(self, index, value): self.szlig[index] = value
    def get_agrave(self): return self.agrave
    def set_agrave(self, agrave): self.agrave = agrave
    def add_agrave(self, value): self.agrave.append(value)
    def insert_agrave_at(self, index, value): self.agrave.insert(index, value)
    def replace_agrave_at(self, index, value): self.agrave[index] = value
    def get_aacute(self): return self.aacute
    def set_aacute(self, aacute): self.aacute = aacute
    def add_aacute(self, value): self.aacute.append(value)
    def insert_aacute_at(self, index, value): self.aacute.insert(index, value)
    def replace_aacute_at(self, index, value): self.aacute[index] = value
    def get_acirc(self): return self.acirc
    def set_acirc(self, acirc): self.acirc = acirc
    def add_acirc(self, value): self.acirc.append(value)
    def insert_acirc_at(self, index, value): self.acirc.insert(index, value)
    def replace_acirc_at(self, index, value): self.acirc[index] = value
    def get_atilde(self): return self.atilde
    def set_atilde(self, atilde): self.atilde = atilde
    def add_atilde(self, value): self.atilde.append(value)
    def insert_atilde_at(self, index, value): self.atilde.insert(index, value)
    def replace_atilde_at(self, index, value): self.atilde[index] = value
    def get_aumlaut(self): return self.aumlaut
    def set_aumlaut(self, aumlaut): self.aumlaut = aumlaut
    def add_aumlaut(self, value): self.aumlaut.append(value)
    def insert_aumlaut_at(self, index, value): self.aumlaut.insert(index, value)
    def replace_aumlaut_at(self, index, value): self.aumlaut[index] = value
    def get_aring(self): return self.aring
    def set_aring(self, aring): self.aring = aring
    def add_aring(self, value): self.aring.append(value)
    def insert_aring_at(self, index, value): self.aring.insert(index, value)
    def replace_aring_at(self, index, value): self.aring[index] = value
    def get_aelig(self): return self.aelig
    def set_aelig(self, aelig): self.aelig = aelig
    def add_aelig(self, value): self.aelig.append(value)
    def insert_aelig_at(self, index, value): self.aelig.insert(index, value)
    def replace_aelig_at(self, index, value): self.aelig[index] = value
    def get_ccedil(self): return self.ccedil
    def set_ccedil(self, ccedil): self.ccedil = ccedil
    def add_ccedil(self, value): self.ccedil.append(value)
    def insert_ccedil_at(self, index, value): self.ccedil.insert(index, value)
    def replace_ccedil_at(self, index, value): self.ccedil[index] = value
    def get_egrave(self): return self.egrave
    def set_egrave(self, egrave): self.egrave = egrave
    def add_egrave(self, value): self.egrave.append(value)
    def insert_egrave_at(self, index, value): self.egrave.insert(index, value)
    def replace_egrave_at(self, index, value): self.egrave[index] = value
    def get_eacute(self): return self.eacute
    def set_eacute(self, eacute): self.eacute = eacute
    def add_eacute(self, value): self.eacute.append(value)
    def insert_eacute_at(self, index, value): self.eacute.insert(index, value)
    def replace_eacute_at(self, index, value): self.eacute[index] = value
    def get_ecirc(self): return self.ecirc
    def set_ecirc(self, ecirc): self.ecirc = ecirc
    def add_ecirc(self, value): self.ecirc.append(value)
    def insert_ecirc_at(self, index, value): self.ecirc.insert(index, value)
    def replace_ecirc_at(self, index, value): self.ecirc[index] = value
    def get_eumlaut(self): return self.eumlaut
    def set_eumlaut(self, eumlaut): self.eumlaut = eumlaut
    def add_eumlaut(self, value): self.eumlaut.append(value)
    def insert_eumlaut_at(self, index, value): self.eumlaut.insert(index, value)
    def replace_eumlaut_at(self, index, value): self.eumlaut[index] = value
    def get_igrave(self): return self.igrave
    def set_igrave(self, igrave): self.igrave = igrave
    def add_igrave(self, value): self.igrave.append(value)
    def insert_igrave_at(self, index, value): self.igrave.insert(index, value)
    def replace_igrave_at(self, index, value): self.igrave[index] = value
    def get_iacute(self): return self.iacute
    def set_iacute(self, iacute): self.iacute = iacute
    def add_iacute(self, value): self.iacute.append(value)
    def insert_iacute_at(self, index, value): self.iacute.insert(index, value)
    def replace_iacute_at(self, index, value): self.iacute[index] = value
    def get_icirc(self): return self.icirc
    def set_icirc(self, icirc): self.icirc = icirc
    def add_icirc(self, value): self.icirc.append(value)
    def insert_icirc_at(self, index, value): self.icirc.insert(index, value)
    def replace_icirc_at(self, index, value): self.icirc[index] = value
    def get_iumlaut(self): return self.iumlaut
    def set_iumlaut(self, iumlaut): self.iumlaut = iumlaut
    def add_iumlaut(self, value): self.iumlaut.append(value)
    def insert_iumlaut_at(self, index, value): self.iumlaut.insert(index, value)
    def replace_iumlaut_at(self, index, value): self.iumlaut[index] = value
    def get_eth(self): return self.eth
    def set_eth(self, eth): self.eth = eth
    def add_eth(self, value): self.eth.append(value)
    def insert_eth_at(self, index, value): self.eth.insert(index, value)
    def replace_eth_at(self, index, value): self.eth[index] = value
    def get_ntilde(self): return self.ntilde
    def set_ntilde(self, ntilde): self.ntilde = ntilde
    def add_ntilde(self, value): self.ntilde.append(value)
    def insert_ntilde_at(self, index, value): self.ntilde.insert(index, value)
    def replace_ntilde_at(self, index, value): self.ntilde[index] = value
    def get_ograve(self): return self.ograve
    def set_ograve(self, ograve): self.ograve = ograve
    def add_ograve(self, value): self.ograve.append(value)
    def insert_ograve_at(self, index, value): self.ograve.insert(index, value)
    def replace_ograve_at(self, index, value): self.ograve[index] = value
    def get_oacute(self): return self.oacute
    def set_oacute(self, oacute): self.oacute = oacute
    def add_oacute(self, value): self.oacute.append(value)
    def insert_oacute_at(self, index, value): self.oacute.insert(index, value)
    def replace_oacute_at(self, index, value): self.oacute[index] = value
    def get_ocirc(self): return self.ocirc
    def set_ocirc(self, ocirc): self.ocirc = ocirc
    def add_ocirc(self, value): self.ocirc.append(value)
    def insert_ocirc_at(self, index, value): self.ocirc.insert(index, value)
    def replace_ocirc_at(self, index, value): self.ocirc[index] = value
    def get_otilde(self): return self.otilde
    def set_otilde(self, otilde): self.otilde = otilde
    def add_otilde(self, value): self.otilde.append(value)
    def insert_otilde_at(self, index, value): self.otilde.insert(index, value)
    def replace_otilde_at(self, index, value): self.otilde[index] = value
    def get_oumlaut(self): return self.oumlaut
    def set_oumlaut(self, oumlaut): self.oumlaut = oumlaut
    def add_oumlaut(self, value): self.oumlaut.append(value)
    def insert_oumlaut_at(self, index, value): self.oumlaut.insert(index, value)
    def replace_oumlaut_at(self, index, value): self.oumlaut[index] = value
    def get_divide(self): return self.divide
    def set_divide(self, divide): self.divide = divide
    def add_divide(self, value): self.divide.append(value)
    def insert_divide_at(self, index, value): self.divide.insert(index, value)
    def replace_divide_at(self, index, value): self.divide[index] = value
    def get_oslash(self): return self.oslash
    def set_oslash(self, oslash): self.oslash = oslash
    def add_oslash(self, value): self.oslash.append(value)
    def insert_oslash_at(self, index, value): self.oslash.insert(index, value)
    def replace_oslash_at(self, index, value): self.oslash[index] = value
    def get_ugrave(self): return self.ugrave
    def set_ugrave(self, ugrave): self.ugrave = ugrave
    def add_ugrave(self, value): self.ugrave.append(value)
    def insert_ugrave_at(self, index, value): self.ugrave.insert(index, value)
    def replace_ugrave_at(self, index, value): self.ugrave[index] = value
    def get_uacute(self): return self.uacute
    def set_uacute(self, uacute): self.uacute = uacute
    def add_uacute(self, value): self.uacute.append(value)
    def insert_uacute_at(self, index, value): self.uacute.insert(index, value)
    def replace_uacute_at(self, index, value): self.uacute[index] = value
    def get_ucirc(self): return self.ucirc
    def set_ucirc(self, ucirc): self.ucirc = ucirc
    def add_ucirc(self, value): self.ucirc.append(value)
    def insert_ucirc_at(self, index, value): self.ucirc.insert(index, value)
    def replace_ucirc_at(self, index, value): self.ucirc[index] = value
    def get_uumlaut(self): return self.uumlaut
    def set_uumlaut(self, uumlaut): self.uumlaut = uumlaut
    def add_uumlaut(self, value): self.uumlaut.append(value)
    def insert_uumlaut_at(self, index, value): self.uumlaut.insert(index, value)
    def replace_uumlaut_at(self, index, value): self.uumlaut[index] = value
    def get_yacute(self): return self.yacute
    def set_yacute(self, yacute): self.yacute = yacute
    def add_yacute(self, value): self.yacute.append(value)
    def insert_yacute_at(self, index, value): self.yacute.insert(index, value)
    def replace_yacute_at(self, index, value): self.yacute[index] = value
    def get_thorn(self): return self.thorn
    def set_thorn(self, thorn): self.thorn = thorn
    def add_thorn(self, value): self.thorn.append(value)
    def insert_thorn_at(self, index, value): self.thorn.insert(index, value)
    def replace_thorn_at(self, index, value): self.thorn[index] = value
    def get_yumlaut(self): return self.yumlaut
    def set_yumlaut(self, yumlaut): self.yumlaut = yumlaut
    def add_yumlaut(self, value): self.yumlaut.append(value)
    def insert_yumlaut_at(self, index, value): self.yumlaut.insert(index, value)
    def replace_yumlaut_at(self, index, value): self.yumlaut[index] = value
    def get_fnof(self): return self.fnof
    def set_fnof(self, fnof): self.fnof = fnof
    def add_fnof(self, value): self.fnof.append(value)
    def insert_fnof_at(self, index, value): self.fnof.insert(index, value)
    def replace_fnof_at(self, index, value): self.fnof[index] = value
    def get_Alpha(self): return self.Alpha
    def set_Alpha(self, Alpha): self.Alpha = Alpha
    def add_Alpha(self, value): self.Alpha.append(value)
    def insert_Alpha_at(self, index, value): self.Alpha.insert(index, value)
    def replace_Alpha_at(self, index, value): self.Alpha[index] = value
    def get_Beta(self): return self.Beta
    def set_Beta(self, Beta): self.Beta = Beta
    def add_Beta(self, value): self.Beta.append(value)
    def insert_Beta_at(self, index, value): self.Beta.insert(index, value)
    def replace_Beta_at(self, index, value): self.Beta[index] = value
    def get_Gamma(self): return self.Gamma
    def set_Gamma(self, Gamma): self.Gamma = Gamma
    def add_Gamma(self, value): self.Gamma.append(value)
    def insert_Gamma_at(self, index, value): self.Gamma.insert(index, value)
    def replace_Gamma_at(self, index, value): self.Gamma[index] = value
    def get_Delta(self): return self.Delta
    def set_Delta(self, Delta): self.Delta = Delta
    def add_Delta(self, value): self.Delta.append(value)
    def insert_Delta_at(self, index, value): self.Delta.insert(index, value)
    def replace_Delta_at(self, index, value): self.Delta[index] = value
    def get_Epsilon(self): return self.Epsilon
    def set_Epsilon(self, Epsilon): self.Epsilon = Epsilon
    def add_Epsilon(self, value): self.Epsilon.append(value)
    def insert_Epsilon_at(self, index, value): self.Epsilon.insert(index, value)
    def replace_Epsilon_at(self, index, value): self.Epsilon[index] = value
    def get_Zeta(self): return self.Zeta
    def set_Zeta(self, Zeta): self.Zeta = Zeta
    def add_Zeta(self, value): self.Zeta.append(value)
    def insert_Zeta_at(self, index, value): self.Zeta.insert(index, value)
    def replace_Zeta_at(self, index, value): self.Zeta[index] = value
    def get_Eta(self): return self.Eta
    def set_Eta(self, Eta): self.Eta = Eta
    def add_Eta(self, value): self.Eta.append(value)
    def insert_Eta_at(self, index, value): self.Eta.insert(index, value)
    def replace_Eta_at(self, index, value): self.Eta[index] = value
    def get_Theta(self): return self.Theta
    def set_Theta(self, Theta): self.Theta = Theta
    def add_Theta(self, value): self.Theta.append(value)
    def insert_Theta_at(self, index, value): self.Theta.insert(index, value)
    def replace_Theta_at(self, index, value): self.Theta[index] = value
    def get_Iota(self): return self.Iota
    def set_Iota(self, Iota): self.Iota = Iota
    def add_Iota(self, value): self.Iota.append(value)
    def insert_Iota_at(self, index, value): self.Iota.insert(index, value)
    def replace_Iota_at(self, index, value): self.Iota[index] = value
    def get_Kappa(self): return self.Kappa
    def set_Kappa(self, Kappa): self.Kappa = Kappa
    def add_Kappa(self, value): self.Kappa.append(value)
    def insert_Kappa_at(self, index, value): self.Kappa.insert(index, value)
    def replace_Kappa_at(self, index, value): self.Kappa[index] = value
    def get_Lambda(self): return self.Lambda
    def set_Lambda(self, Lambda): self.Lambda = Lambda
    def add_Lambda(self, value): self.Lambda.append(value)
    def insert_Lambda_at(self, index, value): self.Lambda.insert(index, value)
    def replace_Lambda_at(self, index, value): self.Lambda[index] = value
    def get_Mu(self): return self.Mu
    def set_Mu(self, Mu): self.Mu = Mu
    def add_Mu(self, value): self.Mu.append(value)
    def insert_Mu_at(self, index, value): self.Mu.insert(index, value)
    def replace_Mu_at(self, index, value): self.Mu[index] = value
    def get_Nu(self): return self.Nu
    def set_Nu(self, Nu): self.Nu = Nu
    def add_Nu(self, value): self.Nu.append(value)
    def insert_Nu_at(self, index, value): self.Nu.insert(index, value)
    def replace_Nu_at(self, index, value): self.Nu[index] = value
    def get_Xi(self): return self.Xi
    def set_Xi(self, Xi): self.Xi = Xi
    def add_Xi(self, value): self.Xi.append(value)
    def insert_Xi_at(self, index, value): self.Xi.insert(index, value)
    def replace_Xi_at(self, index, value): self.Xi[index] = value
    def get_Omicron(self): return self.Omicron
    def set_Omicron(self, Omicron): self.Omicron = Omicron
    def add_Omicron(self, value): self.Omicron.append(value)
    def insert_Omicron_at(self, index, value): self.Omicron.insert(index, value)
    def replace_Omicron_at(self, index, value): self.Omicron[index] = value
    def get_Pi(self): return self.Pi
    def set_Pi(self, Pi): self.Pi = Pi
    def add_Pi(self, value): self.Pi.append(value)
    def insert_Pi_at(self, index, value): self.Pi.insert(index, value)
    def replace_Pi_at(self, index, value): self.Pi[index] = value
    def get_Rho(self): return self.Rho
    def set_Rho(self, Rho): self.Rho = Rho
    def add_Rho(self, value): self.Rho.append(value)
    def insert_Rho_at(self, index, value): self.Rho.insert(index, value)
    def replace_Rho_at(self, index, value): self.Rho[index] = value
    def get_Sigma(self): return self.Sigma
    def set_Sigma(self, Sigma): self.Sigma = Sigma
    def add_Sigma(self, value): self.Sigma.append(value)
    def insert_Sigma_at(self, index, value): self.Sigma.insert(index, value)
    def replace_Sigma_at(self, index, value): self.Sigma[index] = value
    def get_Tau(self): return self.Tau
    def set_Tau(self, Tau): self.Tau = Tau
    def add_Tau(self, value): self.Tau.append(value)
    def insert_Tau_at(self, index, value): self.Tau.insert(index, value)
    def replace_Tau_at(self, index, value): self.Tau[index] = value
    def get_Upsilon(self): return self.Upsilon
    def set_Upsilon(self, Upsilon): self.Upsilon = Upsilon
    def add_Upsilon(self, value): self.Upsilon.append(value)
    def insert_Upsilon_at(self, index, value): self.Upsilon.insert(index, value)
    def replace_Upsilon_at(self, index, value): self.Upsilon[index] = value
    def get_Phi(self): return self.Phi
    def set_Phi(self, Phi): self.Phi = Phi
    def add_Phi(self, value): self.Phi.append(value)
    def insert_Phi_at(self, index, value): self.Phi.insert(index, value)
    def replace_Phi_at(self, index, value): self.Phi[index] = value
    def get_Chi(self): return self.Chi
    def set_Chi(self, Chi): self.Chi = Chi
    def add_Chi(self, value): self.Chi.append(value)
    def insert_Chi_at(self, index, value): self.Chi.insert(index, value)
    def replace_Chi_at(self, index, value): self.Chi[index] = value
    def get_Psi(self): return self.Psi
    def set_Psi(self, Psi): self.Psi = Psi
    def add_Psi(self, value): self.Psi.append(value)
    def insert_Psi_at(self, index, value): self.Psi.insert(index, value)
    def replace_Psi_at(self, index, value): self.Psi[index] = value
    def get_Omega(self): return self.Omega
    def set_Omega(self, Omega): self.Omega = Omega
    def add_Omega(self, value): self.Omega.append(value)
    def insert_Omega_at(self, index, value): self.Omega.insert(index, value)
    def replace_Omega_at(self, index, value): self.Omega[index] = value
    def get_alpha(self): return self.alpha
    def set_alpha(self, alpha): self.alpha = alpha
    def add_alpha(self, value): self.alpha.append(value)
    def insert_alpha_at(self, index, value): self.alpha.insert(index, value)
    def replace_alpha_at(self, index, value): self.alpha[index] = value
    def get_beta(self): return self.beta
    def set_beta(self, beta): self.beta = beta
    def add_beta(self, value): self.beta.append(value)
    def insert_beta_at(self, index, value): self.beta.insert(index, value)
    def replace_beta_at(self, index, value): self.beta[index] = value
    def get_gamma(self): return self.gamma
    def set_gamma(self, gamma): self.gamma = gamma
    def add_gamma(self, value): self.gamma.append(value)
    def insert_gamma_at(self, index, value): self.gamma.insert(index, value)
    def replace_gamma_at(self, index, value): self.gamma[index] = value
    def get_delta(self): return self.delta
    def set_delta(self, delta): self.delta = delta
    def add_delta(self, value): self.delta.append(value)
    def insert_delta_at(self, index, value): self.delta.insert(index, value)
    def replace_delta_at(self, index, value): self.delta[index] = value
    def get_epsilon(self): return self.epsilon
    def set_epsilon(self, epsilon): self.epsilon = epsilon
    def add_epsilon(self, value): self.epsilon.append(value)
    def insert_epsilon_at(self, index, value): self.epsilon.insert(index, value)
    def replace_epsilon_at(self, index, value): self.epsilon[index] = value
    def get_zeta(self): return self.zeta
    def set_zeta(self, zeta): self.zeta = zeta
    def add_zeta(self, value): self.zeta.append(value)
    def insert_zeta_at(self, index, value): self.zeta.insert(index, value)
    def replace_zeta_at(self, index, value): self.zeta[index] = value
    def get_eta(self): return self.eta
    def set_eta(self, eta): self.eta = eta
    def add_eta(self, value): self.eta.append(value)
    def insert_eta_at(self, index, value): self.eta.insert(index, value)
    def replace_eta_at(self, index, value): self.eta[index] = value
    def get_theta(self): return self.theta
    def set_theta(self, theta): self.theta = theta
    def add_theta(self, value): self.theta.append(value)
    def insert_theta_at(self, index, value): self.theta.insert(index, value)
    def replace_theta_at(self, index, value): self.theta[index] = value
    def get_iota(self): return self.iota
    def set_iota(self, iota): self.iota = iota
    def add_iota(self, value): self.iota.append(value)
    def insert_iota_at(self, index, value): self.iota.insert(index, value)
    def replace_iota_at(self, index, value): self.iota[index] = value
    def get_kappa(self): return self.kappa
    def set_kappa(self, kappa): self.kappa = kappa
    def add_kappa(self, value): self.kappa.append(value)
    def insert_kappa_at(self, index, value): self.kappa.insert(index, value)
    def replace_kappa_at(self, index, value): self.kappa[index] = value
    def get_lambda(self): return self.lambda_
    def set_lambda(self, lambda_): self.lambda_ = lambda_
    def add_lambda(self, value): self.lambda_.append(value)
    def insert_lambda_at(self, index, value): self.lambda_.insert(index, value)
    def replace_lambda_at(self, index, value): self.lambda_[index] = value
    def get_mu(self): return self.mu
    def set_mu(self, mu): self.mu = mu
    def add_mu(self, value): self.mu.append(value)
    def insert_mu_at(self, index, value): self.mu.insert(index, value)
    def replace_mu_at(self, index, value): self.mu[index] = value
    def get_nu(self): return self.nu
    def set_nu(self, nu): self.nu = nu
    def add_nu(self, value): self.nu.append(value)
    def insert_nu_at(self, index, value): self.nu.insert(index, value)
    def replace_nu_at(self, index, value): self.nu[index] = value
    def get_xi(self): return self.xi
    def set_xi(self, xi): self.xi = xi
    def add_xi(self, value): self.xi.append(value)
    def insert_xi_at(self, index, value): self.xi.insert(index, value)
    def replace_xi_at(self, index, value): self.xi[index] = value
    def get_omicron(self): return self.omicron
    def set_omicron(self, omicron): self.omicron = omicron
    def add_omicron(self, value): self.omicron.append(value)
    def insert_omicron_at(self, index, value): self.omicron.insert(index, value)
    def replace_omicron_at(self, index, value): self.omicron[index] = value
    def get_pi(self): return self.pi
    def set_pi(self, pi): self.pi = pi
    def add_pi(self, value): self.pi.append(value)
    def insert_pi_at(self, index, value): self.pi.insert(index, value)
    def replace_pi_at(self, index, value): self.pi[index] = value
    def get_rho(self): return self.rho
    def set_rho(self, rho): self.rho = rho
    def add_rho(self, value): self.rho.append(value)
    def insert_rho_at(self, index, value): self.rho.insert(index, value)
    def replace_rho_at(self, index, value): self.rho[index] = value
    def get_sigmaf(self): return self.sigmaf
    def set_sigmaf(self, sigmaf): self.sigmaf = sigmaf
    def add_sigmaf(self, value): self.sigmaf.append(value)
    def insert_sigmaf_at(self, index, value): self.sigmaf.insert(index, value)
    def replace_sigmaf_at(self, index, value): self.sigmaf[index] = value
    def get_sigma(self): return self.sigma
    def set_sigma(self, sigma): self.sigma = sigma
    def add_sigma(self, value): self.sigma.append(value)
    def insert_sigma_at(self, index, value): self.sigma.insert(index, value)
    def replace_sigma_at(self, index, value): self.sigma[index] = value
    def get_tau(self): return self.tau
    def set_tau(self, tau): self.tau = tau
    def add_tau(self, value): self.tau.append(value)
    def insert_tau_at(self, index, value): self.tau.insert(index, value)
    def replace_tau_at(self, index, value): self.tau[index] = value
    def get_upsilon(self): return self.upsilon
    def set_upsilon(self, upsilon): self.upsilon = upsilon
    def add_upsilon(self, value): self.upsilon.append(value)
    def insert_upsilon_at(self, index, value): self.upsilon.insert(index, value)
    def replace_upsilon_at(self, index, value): self.upsilon[index] = value
    def get_phi(self): return self.phi
    def set_phi(self, phi): self.phi = phi
    def add_phi(self, value): self.phi.append(value)
    def insert_phi_at(self, index, value): self.phi.insert(index, value)
    def replace_phi_at(self, index, value): self.phi[index] = value
    def get_chi(self): return self.chi
    def set_chi(self, chi): self.chi = chi
    def add_chi(self, value): self.chi.append(value)
    def insert_chi_at(self, index, value): self.chi.insert(index, value)
    def replace_chi_at(self, index, value): self.chi[index] = value
    def get_psi(self): return self.psi
    def set_psi(self, psi): self.psi = psi
    def add_psi(self, value): self.psi.append(value)
    def insert_psi_at(self, index, value): self.psi.insert(index, value)
    def replace_psi_at(self, index, value): self.psi[index] = value
    def get_omega(self): return self.omega
    def set_omega(self, omega): self.omega = omega
    def add_omega(self, value): self.omega.append(value)
    def insert_omega_at(self, index, value): self.omega.insert(index, value)
    def replace_omega_at(self, index, value): self.omega[index] = value
    def get_thetasym(self): return self.thetasym
    def set_thetasym(self, thetasym): self.thetasym = thetasym
    def add_thetasym(self, value): self.thetasym.append(value)
    def insert_thetasym_at(self, index, value): self.thetasym.insert(index, value)
    def replace_thetasym_at(self, index, value): self.thetasym[index] = value
    def get_upsih(self): return self.upsih
    def set_upsih(self, upsih): self.upsih = upsih
    def add_upsih(self, value): self.upsih.append(value)
    def insert_upsih_at(self, index, value): self.upsih.insert(index, value)
    def replace_upsih_at(self, index, value): self.upsih[index] = value
    def get_piv(self): return self.piv
    def set_piv(self, piv): self.piv = piv
    def add_piv(self, value): self.piv.append(value)
    def insert_piv_at(self, index, value): self.piv.insert(index, value)
    def replace_piv_at(self, index, value): self.piv[index] = value
    def get_bull(self): return self.bull
    def set_bull(self, bull): self.bull = bull
    def add_bull(self, value): self.bull.append(value)
    def insert_bull_at(self, index, value): self.bull.insert(index, value)
    def replace_bull_at(self, index, value): self.bull[index] = value
    def get_hellip(self): return self.hellip
    def set_hellip(self, hellip): self.hellip = hellip
    def add_hellip(self, value): self.hellip.append(value)
    def insert_hellip_at(self, index, value): self.hellip.insert(index, value)
    def replace_hellip_at(self, index, value): self.hellip[index] = value
    def get_prime(self): return self.prime
    def set_prime(self, prime): self.prime = prime
    def add_prime(self, value): self.prime.append(value)
    def insert_prime_at(self, index, value): self.prime.insert(index, value)
    def replace_prime_at(self, index, value): self.prime[index] = value
    def get_Prime(self): return self.Prime
    def set_Prime(self, Prime): self.Prime = Prime
    def add_Prime(self, value): self.Prime.append(value)
    def insert_Prime_at(self, index, value): self.Prime.insert(index, value)
    def replace_Prime_at(self, index, value): self.Prime[index] = value
    def get_oline(self): return self.oline
    def set_oline(self, oline): self.oline = oline
    def add_oline(self, value): self.oline.append(value)
    def insert_oline_at(self, index, value): self.oline.insert(index, value)
    def replace_oline_at(self, index, value): self.oline[index] = value
    def get_frasl(self): return self.frasl
    def set_frasl(self, frasl): self.frasl = frasl
    def add_frasl(self, value): self.frasl.append(value)
    def insert_frasl_at(self, index, value): self.frasl.insert(index, value)
    def replace_frasl_at(self, index, value): self.frasl[index] = value
    def get_weierp(self): return self.weierp
    def set_weierp(self, weierp): self.weierp = weierp
    def add_weierp(self, value): self.weierp.append(value)
    def insert_weierp_at(self, index, value): self.weierp.insert(index, value)
    def replace_weierp_at(self, index, value): self.weierp[index] = value
    def get_imaginary(self): return self.imaginary
    def set_imaginary(self, imaginary): self.imaginary = imaginary
    def add_imaginary(self, value): self.imaginary.append(value)
    def insert_imaginary_at(self, index, value): self.imaginary.insert(index, value)
    def replace_imaginary_at(self, index, value): self.imaginary[index] = value
    def get_real(self): return self.real
    def set_real(self, real): self.real = real
    def add_real(self, value): self.real.append(value)
    def insert_real_at(self, index, value): self.real.insert(index, value)
    def replace_real_at(self, index, value): self.real[index] = value
    def get_trademark(self): return self.trademark
    def set_trademark(self, trademark): self.trademark = trademark
    def add_trademark(self, value): self.trademark.append(value)
    def insert_trademark_at(self, index, value): self.trademark.insert(index, value)
    def replace_trademark_at(self, index, value): self.trademark[index] = value
    def get_alefsym(self): return self.alefsym
    def set_alefsym(self, alefsym): self.alefsym = alefsym
    def add_alefsym(self, value): self.alefsym.append(value)
    def insert_alefsym_at(self, index, value): self.alefsym.insert(index, value)
    def replace_alefsym_at(self, index, value): self.alefsym[index] = value
    def get_larr(self): return self.larr
    def set_larr(self, larr): self.larr = larr
    def add_larr(self, value): self.larr.append(value)
    def insert_larr_at(self, index, value): self.larr.insert(index, value)
    def replace_larr_at(self, index, value): self.larr[index] = value
    def get_uarr(self): return self.uarr
    def set_uarr(self, uarr): self.uarr = uarr
    def add_uarr(self, value): self.uarr.append(value)
    def insert_uarr_at(self, index, value): self.uarr.insert(index, value)
    def replace_uarr_at(self, index, value): self.uarr[index] = value
    def get_rarr(self): return self.rarr
    def set_rarr(self, rarr): self.rarr = rarr
    def add_rarr(self, value): self.rarr.append(value)
    def insert_rarr_at(self, index, value): self.rarr.insert(index, value)
    def replace_rarr_at(self, index, value): self.rarr[index] = value
    def get_darr(self): return self.darr
    def set_darr(self, darr): self.darr = darr
    def add_darr(self, value): self.darr.append(value)
    def insert_darr_at(self, index, value): self.darr.insert(index, value)
    def replace_darr_at(self, index, value): self.darr[index] = value
    def get_harr(self): return self.harr
    def set_harr(self, harr): self.harr = harr
    def add_harr(self, value): self.harr.append(value)
    def insert_harr_at(self, index, value): self.harr.insert(index, value)
    def replace_harr_at(self, index, value): self.harr[index] = value
    def get_crarr(self): return self.crarr
    def set_crarr(self, crarr): self.crarr = crarr
    def add_crarr(self, value): self.crarr.append(value)
    def insert_crarr_at(self, index, value): self.crarr.insert(index, value)
    def replace_crarr_at(self, index, value): self.crarr[index] = value
    def get_lArr(self): return self.lArr
    def set_lArr(self, lArr): self.lArr = lArr
    def add_lArr(self, value): self.lArr.append(value)
    def insert_lArr_at(self, index, value): self.lArr.insert(index, value)
    def replace_lArr_at(self, index, value): self.lArr[index] = value
    def get_uArr(self): return self.uArr
    def set_uArr(self, uArr): self.uArr = uArr
    def add_uArr(self, value): self.uArr.append(value)
    def insert_uArr_at(self, index, value): self.uArr.insert(index, value)
    def replace_uArr_at(self, index, value): self.uArr[index] = value
    def get_rArr(self): return self.rArr
    def set_rArr(self, rArr): self.rArr = rArr
    def add_rArr(self, value): self.rArr.append(value)
    def insert_rArr_at(self, index, value): self.rArr.insert(index, value)
    def replace_rArr_at(self, index, value): self.rArr[index] = value
    def get_dArr(self): return self.dArr
    def set_dArr(self, dArr): self.dArr = dArr
    def add_dArr(self, value): self.dArr.append(value)
    def insert_dArr_at(self, index, value): self.dArr.insert(index, value)
    def replace_dArr_at(self, index, value): self.dArr[index] = value
    def get_hArr(self): return self.hArr
    def set_hArr(self, hArr): self.hArr = hArr
    def add_hArr(self, value): self.hArr.append(value)
    def insert_hArr_at(self, index, value): self.hArr.insert(index, value)
    def replace_hArr_at(self, index, value): self.hArr[index] = value
    def get_forall(self): return self.forall
    def set_forall(self, forall): self.forall = forall
    def add_forall(self, value): self.forall.append(value)
    def insert_forall_at(self, index, value): self.forall.insert(index, value)
    def replace_forall_at(self, index, value): self.forall[index] = value
    def get_part(self): return self.part
    def set_part(self, part): self.part = part
    def add_part(self, value): self.part.append(value)
    def insert_part_at(self, index, value): self.part.insert(index, value)
    def replace_part_at(self, index, value): self.part[index] = value
    def get_exist(self): return self.exist
    def set_exist(self, exist): self.exist = exist
    def add_exist(self, value): self.exist.append(value)
    def insert_exist_at(self, index, value): self.exist.insert(index, value)
    def replace_exist_at(self, index, value): self.exist[index] = value
    def get_empty(self): return self.empty
    def set_empty(self, empty): self.empty = empty
    def add_empty(self, value): self.empty.append(value)
    def insert_empty_at(self, index, value): self.empty.insert(index, value)
    def replace_empty_at(self, index, value): self.empty[index] = value
    def get_nabla(self): return self.nabla
    def set_nabla(self, nabla): self.nabla = nabla
    def add_nabla(self, value): self.nabla.append(value)
    def insert_nabla_at(self, index, value): self.nabla.insert(index, value)
    def replace_nabla_at(self, index, value): self.nabla[index] = value
    def get_isin(self): return self.isin
    def set_isin(self, isin): self.isin = isin
    def add_isin(self, value): self.isin.append(value)
    def insert_isin_at(self, index, value): self.isin.insert(index, value)
    def replace_isin_at(self, index, value): self.isin[index] = value
    def get_notin(self): return self.notin
    def set_notin(self, notin): self.notin = notin
    def add_notin(self, value): self.notin.append(value)
    def insert_notin_at(self, index, value): self.notin.insert(index, value)
    def replace_notin_at(self, index, value): self.notin[index] = value
    def get_ni(self): return self.ni
    def set_ni(self, ni): self.ni = ni
    def add_ni(self, value): self.ni.append(value)
    def insert_ni_at(self, index, value): self.ni.insert(index, value)
    def replace_ni_at(self, index, value): self.ni[index] = value
    def get_prod(self): return self.prod
    def set_prod(self, prod): self.prod = prod
    def add_prod(self, value): self.prod.append(value)
    def insert_prod_at(self, index, value): self.prod.insert(index, value)
    def replace_prod_at(self, index, value): self.prod[index] = value
    def get_sum(self): return self.sum
    def set_sum(self, sum): self.sum = sum
    def add_sum(self, value): self.sum.append(value)
    def insert_sum_at(self, index, value): self.sum.insert(index, value)
    def replace_sum_at(self, index, value): self.sum[index] = value
    def get_minus(self): return self.minus
    def set_minus(self, minus): self.minus = minus
    def add_minus(self, value): self.minus.append(value)
    def insert_minus_at(self, index, value): self.minus.insert(index, value)
    def replace_minus_at(self, index, value): self.minus[index] = value
    def get_lowast(self): return self.lowast
    def set_lowast(self, lowast): self.lowast = lowast
    def add_lowast(self, value): self.lowast.append(value)
    def insert_lowast_at(self, index, value): self.lowast.insert(index, value)
    def replace_lowast_at(self, index, value): self.lowast[index] = value
    def get_radic(self): return self.radic
    def set_radic(self, radic): self.radic = radic
    def add_radic(self, value): self.radic.append(value)
    def insert_radic_at(self, index, value): self.radic.insert(index, value)
    def replace_radic_at(self, index, value): self.radic[index] = value
    def get_prop(self): return self.prop
    def set_prop(self, prop): self.prop = prop
    def add_prop(self, value): self.prop.append(value)
    def insert_prop_at(self, index, value): self.prop.insert(index, value)
    def replace_prop_at(self, index, value): self.prop[index] = value
    def get_infin(self): return self.infin
    def set_infin(self, infin): self.infin = infin
    def add_infin(self, value): self.infin.append(value)
    def insert_infin_at(self, index, value): self.infin.insert(index, value)
    def replace_infin_at(self, index, value): self.infin[index] = value
    def get_ang(self): return self.ang
    def set_ang(self, ang): self.ang = ang
    def add_ang(self, value): self.ang.append(value)
    def insert_ang_at(self, index, value): self.ang.insert(index, value)
    def replace_ang_at(self, index, value): self.ang[index] = value
    def get_and(self): return self.and_
    def set_and(self, and_): self.and_ = and_
    def add_and(self, value): self.and_.append(value)
    def insert_and_at(self, index, value): self.and_.insert(index, value)
    def replace_and_at(self, index, value): self.and_[index] = value
    def get_or(self): return self.or_
    def set_or(self, or_): self.or_ = or_
    def add_or(self, value): self.or_.append(value)
    def insert_or_at(self, index, value): self.or_.insert(index, value)
    def replace_or_at(self, index, value): self.or_[index] = value
    def get_cap(self): return self.cap
    def set_cap(self, cap): self.cap = cap
    def add_cap(self, value): self.cap.append(value)
    def insert_cap_at(self, index, value): self.cap.insert(index, value)
    def replace_cap_at(self, index, value): self.cap[index] = value
    def get_cup(self): return self.cup
    def set_cup(self, cup): self.cup = cup
    def add_cup(self, value): self.cup.append(value)
    def insert_cup_at(self, index, value): self.cup.insert(index, value)
    def replace_cup_at(self, index, value): self.cup[index] = value
    def get_int(self): return self.int
    def set_int(self, int): self.int = int
    def add_int(self, value): self.int.append(value)
    def insert_int_at(self, index, value): self.int.insert(index, value)
    def replace_int_at(self, index, value): self.int[index] = value
    def get_there4(self): return self.there4
    def set_there4(self, there4): self.there4 = there4
    def add_there4(self, value): self.there4.append(value)
    def insert_there4_at(self, index, value): self.there4.insert(index, value)
    def replace_there4_at(self, index, value): self.there4[index] = value
    def get_sim(self): return self.sim
    def set_sim(self, sim): self.sim = sim
    def add_sim(self, value): self.sim.append(value)
    def insert_sim_at(self, index, value): self.sim.insert(index, value)
    def replace_sim_at(self, index, value): self.sim[index] = value
    def get_cong(self): return self.cong
    def set_cong(self, cong): self.cong = cong
    def add_cong(self, value): self.cong.append(value)
    def insert_cong_at(self, index, value): self.cong.insert(index, value)
    def replace_cong_at(self, index, value): self.cong[index] = value
    def get_asymp(self): return self.asymp
    def set_asymp(self, asymp): self.asymp = asymp
    def add_asymp(self, value): self.asymp.append(value)
    def insert_asymp_at(self, index, value): self.asymp.insert(index, value)
    def replace_asymp_at(self, index, value): self.asymp[index] = value
    def get_ne(self): return self.ne
    def set_ne(self, ne): self.ne = ne
    def add_ne(self, value): self.ne.append(value)
    def insert_ne_at(self, index, value): self.ne.insert(index, value)
    def replace_ne_at(self, index, value): self.ne[index] = value
    def get_equiv(self): return self.equiv
    def set_equiv(self, equiv): self.equiv = equiv
    def add_equiv(self, value): self.equiv.append(value)
    def insert_equiv_at(self, index, value): self.equiv.insert(index, value)
    def replace_equiv_at(self, index, value): self.equiv[index] = value
    def get_le(self): return self.le
    def set_le(self, le): self.le = le
    def add_le(self, value): self.le.append(value)
    def insert_le_at(self, index, value): self.le.insert(index, value)
    def replace_le_at(self, index, value): self.le[index] = value
    def get_ge(self): return self.ge
    def set_ge(self, ge): self.ge = ge
    def add_ge(self, value): self.ge.append(value)
    def insert_ge_at(self, index, value): self.ge.insert(index, value)
    def replace_ge_at(self, index, value): self.ge[index] = value
    def get_sub(self): return self.sub
    def set_sub(self, sub): self.sub = sub
    def add_sub(self, value): self.sub.append(value)
    def insert_sub_at(self, index, value): self.sub.insert(index, value)
    def replace_sub_at(self, index, value): self.sub[index] = value
    def get_sup(self): return self.sup
    def set_sup(self, sup): self.sup = sup
    def add_sup(self, value): self.sup.append(value)
    def insert_sup_at(self, index, value): self.sup.insert(index, value)
    def replace_sup_at(self, index, value): self.sup[index] = value
    def get_nsub(self): return self.nsub
    def set_nsub(self, nsub): self.nsub = nsub
    def add_nsub(self, value): self.nsub.append(value)
    def insert_nsub_at(self, index, value): self.nsub.insert(index, value)
    def replace_nsub_at(self, index, value): self.nsub[index] = value
    def get_sube(self): return self.sube
    def set_sube(self, sube): self.sube = sube
    def add_sube(self, value): self.sube.append(value)
    def insert_sube_at(self, index, value): self.sube.insert(index, value)
    def replace_sube_at(self, index, value): self.sube[index] = value
    def get_supe(self): return self.supe
    def set_supe(self, supe): self.supe = supe
    def add_supe(self, value): self.supe.append(value)
    def insert_supe_at(self, index, value): self.supe.insert(index, value)
    def replace_supe_at(self, index, value): self.supe[index] = value
    def get_oplus(self): return self.oplus
    def set_oplus(self, oplus): self.oplus = oplus
    def add_oplus(self, value): self.oplus.append(value)
    def insert_oplus_at(self, index, value): self.oplus.insert(index, value)
    def replace_oplus_at(self, index, value): self.oplus[index] = value
    def get_otimes(self): return self.otimes
    def set_otimes(self, otimes): self.otimes = otimes
    def add_otimes(self, value): self.otimes.append(value)
    def insert_otimes_at(self, index, value): self.otimes.insert(index, value)
    def replace_otimes_at(self, index, value): self.otimes[index] = value
    def get_perp(self): return self.perp
    def set_perp(self, perp): self.perp = perp
    def add_perp(self, value): self.perp.append(value)
    def insert_perp_at(self, index, value): self.perp.insert(index, value)
    def replace_perp_at(self, index, value): self.perp[index] = value
    def get_sdot(self): return self.sdot
    def set_sdot(self, sdot): self.sdot = sdot
    def add_sdot(self, value): self.sdot.append(value)
    def insert_sdot_at(self, index, value): self.sdot.insert(index, value)
    def replace_sdot_at(self, index, value): self.sdot[index] = value
    def get_lceil(self): return self.lceil
    def set_lceil(self, lceil): self.lceil = lceil
    def add_lceil(self, value): self.lceil.append(value)
    def insert_lceil_at(self, index, value): self.lceil.insert(index, value)
    def replace_lceil_at(self, index, value): self.lceil[index] = value
    def get_rceil(self): return self.rceil
    def set_rceil(self, rceil): self.rceil = rceil
    def add_rceil(self, value): self.rceil.append(value)
    def insert_rceil_at(self, index, value): self.rceil.insert(index, value)
    def replace_rceil_at(self, index, value): self.rceil[index] = value
    def get_lfloor(self): return self.lfloor
    def set_lfloor(self, lfloor): self.lfloor = lfloor
    def add_lfloor(self, value): self.lfloor.append(value)
    def insert_lfloor_at(self, index, value): self.lfloor.insert(index, value)
    def replace_lfloor_at(self, index, value): self.lfloor[index] = value
    def get_rfloor(self): return self.rfloor
    def set_rfloor(self, rfloor): self.rfloor = rfloor
    def add_rfloor(self, value): self.rfloor.append(value)
    def insert_rfloor_at(self, index, value): self.rfloor.insert(index, value)
    def replace_rfloor_at(self, index, value): self.rfloor[index] = value
    def get_lang(self): return self.lang
    def set_lang(self, lang): self.lang = lang
    def add_lang(self, value): self.lang.append(value)
    def insert_lang_at(self, index, value): self.lang.insert(index, value)
    def replace_lang_at(self, index, value): self.lang[index] = value
    def get_rang(self): return self.rang
    def set_rang(self, rang): self.rang = rang
    def add_rang(self, value): self.rang.append(value)
    def insert_rang_at(self, index, value): self.rang.insert(index, value)
    def replace_rang_at(self, index, value): self.rang[index] = value
    def get_loz(self): return self.loz
    def set_loz(self, loz): self.loz = loz
    def add_loz(self, value): self.loz.append(value)
    def insert_loz_at(self, index, value): self.loz.insert(index, value)
    def replace_loz_at(self, index, value): self.loz[index] = value
    def get_spades(self): return self.spades
    def set_spades(self, spades): self.spades = spades
    def add_spades(self, value): self.spades.append(value)
    def insert_spades_at(self, index, value): self.spades.insert(index, value)
    def replace_spades_at(self, index, value): self.spades[index] = value
    def get_clubs(self): return self.clubs
    def set_clubs(self, clubs): self.clubs = clubs
    def add_clubs(self, value): self.clubs.append(value)
    def insert_clubs_at(self, index, value): self.clubs.insert(index, value)
    def replace_clubs_at(self, index, value): self.clubs[index] = value
    def get_hearts(self): return self.hearts
    def set_hearts(self, hearts): self.hearts = hearts
    def add_hearts(self, value): self.hearts.append(value)
    def insert_hearts_at(self, index, value): self.hearts.insert(index, value)
    def replace_hearts_at(self, index, value): self.hearts[index] = value
    def get_diams(self): return self.diams
    def set_diams(self, diams): self.diams = diams
    def add_diams(self, value): self.diams.append(value)
    def insert_diams_at(self, index, value): self.diams.insert(index, value)
    def replace_diams_at(self, index, value): self.diams[index] = value
    def get_OElig(self): return self.OElig
    def set_OElig(self, OElig): self.OElig = OElig
    def add_OElig(self, value): self.OElig.append(value)
    def insert_OElig_at(self, index, value): self.OElig.insert(index, value)
    def replace_OElig_at(self, index, value): self.OElig[index] = value
    def get_oelig(self): return self.oelig
    def set_oelig(self, oelig): self.oelig = oelig
    def add_oelig(self, value): self.oelig.append(value)
    def insert_oelig_at(self, index, value): self.oelig.insert(index, value)
    def replace_oelig_at(self, index, value): self.oelig[index] = value
    def get_Scaron(self): return self.Scaron
    def set_Scaron(self, Scaron): self.Scaron = Scaron
    def add_Scaron(self, value): self.Scaron.append(value)
    def insert_Scaron_at(self, index, value): self.Scaron.insert(index, value)
    def replace_Scaron_at(self, index, value): self.Scaron[index] = value
    def get_scaron(self): return self.scaron
    def set_scaron(self, scaron): self.scaron = scaron
    def add_scaron(self, value): self.scaron.append(value)
    def insert_scaron_at(self, index, value): self.scaron.insert(index, value)
    def replace_scaron_at(self, index, value): self.scaron[index] = value
    def get_Yumlaut(self): return self.Yumlaut
    def set_Yumlaut(self, Yumlaut): self.Yumlaut = Yumlaut
    def add_Yumlaut(self, value): self.Yumlaut.append(value)
    def insert_Yumlaut_at(self, index, value): self.Yumlaut.insert(index, value)
    def replace_Yumlaut_at(self, index, value): self.Yumlaut[index] = value
    def get_circ(self): return self.circ
    def set_circ(self, circ): self.circ = circ
    def add_circ(self, value): self.circ.append(value)
    def insert_circ_at(self, index, value): self.circ.insert(index, value)
    def replace_circ_at(self, index, value): self.circ[index] = value
    def get_tilde(self): return self.tilde
    def set_tilde(self, tilde): self.tilde = tilde
    def add_tilde(self, value): self.tilde.append(value)
    def insert_tilde_at(self, index, value): self.tilde.insert(index, value)
    def replace_tilde_at(self, index, value): self.tilde[index] = value
    def get_ensp(self): return self.ensp
    def set_ensp(self, ensp): self.ensp = ensp
    def add_ensp(self, value): self.ensp.append(value)
    def insert_ensp_at(self, index, value): self.ensp.insert(index, value)
    def replace_ensp_at(self, index, value): self.ensp[index] = value
    def get_emsp(self): return self.emsp
    def set_emsp(self, emsp): self.emsp = emsp
    def add_emsp(self, value): self.emsp.append(value)
    def insert_emsp_at(self, index, value): self.emsp.insert(index, value)
    def replace_emsp_at(self, index, value): self.emsp[index] = value
    def get_thinsp(self): return self.thinsp
    def set_thinsp(self, thinsp): self.thinsp = thinsp
    def add_thinsp(self, value): self.thinsp.append(value)
    def insert_thinsp_at(self, index, value): self.thinsp.insert(index, value)
    def replace_thinsp_at(self, index, value): self.thinsp[index] = value
    def get_zwnj(self): return self.zwnj
    def set_zwnj(self, zwnj): self.zwnj = zwnj
    def add_zwnj(self, value): self.zwnj.append(value)
    def insert_zwnj_at(self, index, value): self.zwnj.insert(index, value)
    def replace_zwnj_at(self, index, value): self.zwnj[index] = value
    def get_zwj(self): return self.zwj
    def set_zwj(self, zwj): self.zwj = zwj
    def add_zwj(self, value): self.zwj.append(value)
    def insert_zwj_at(self, index, value): self.zwj.insert(index, value)
    def replace_zwj_at(self, index, value): self.zwj[index] = value
    def get_lrm(self): return self.lrm
    def set_lrm(self, lrm): self.lrm = lrm
    def add_lrm(self, value): self.lrm.append(value)
    def insert_lrm_at(self, index, value): self.lrm.insert(index, value)
    def replace_lrm_at(self, index, value): self.lrm[index] = value
    def get_rlm(self): return self.rlm
    def set_rlm(self, rlm): self.rlm = rlm
    def add_rlm(self, value): self.rlm.append(value)
    def insert_rlm_at(self, index, value): self.rlm.insert(index, value)
    def replace_rlm_at(self, index, value): self.rlm[index] = value
    def get_ndash(self): return self.ndash
    def set_ndash(self, ndash): self.ndash = ndash
    def add_ndash(self, value): self.ndash.append(value)
    def insert_ndash_at(self, index, value): self.ndash.insert(index, value)
    def replace_ndash_at(self, index, value): self.ndash[index] = value
    def get_mdash(self): return self.mdash
    def set_mdash(self, mdash): self.mdash = mdash
    def add_mdash(self, value): self.mdash.append(value)
    def insert_mdash_at(self, index, value): self.mdash.insert(index, value)
    def replace_mdash_at(self, index, value): self.mdash[index] = value
    def get_lsquo(self): return self.lsquo
    def set_lsquo(self, lsquo): self.lsquo = lsquo
    def add_lsquo(self, value): self.lsquo.append(value)
    def insert_lsquo_at(self, index, value): self.lsquo.insert(index, value)
    def replace_lsquo_at(self, index, value): self.lsquo[index] = value
    def get_rsquo(self): return self.rsquo
    def set_rsquo(self, rsquo): self.rsquo = rsquo
    def add_rsquo(self, value): self.rsquo.append(value)
    def insert_rsquo_at(self, index, value): self.rsquo.insert(index, value)
    def replace_rsquo_at(self, index, value): self.rsquo[index] = value
    def get_sbquo(self): return self.sbquo
    def set_sbquo(self, sbquo): self.sbquo = sbquo
    def add_sbquo(self, value): self.sbquo.append(value)
    def insert_sbquo_at(self, index, value): self.sbquo.insert(index, value)
    def replace_sbquo_at(self, index, value): self.sbquo[index] = value
    def get_ldquo(self): return self.ldquo
    def set_ldquo(self, ldquo): self.ldquo = ldquo
    def add_ldquo(self, value): self.ldquo.append(value)
    def insert_ldquo_at(self, index, value): self.ldquo.insert(index, value)
    def replace_ldquo_at(self, index, value): self.ldquo[index] = value
    def get_rdquo(self): return self.rdquo
    def set_rdquo(self, rdquo): self.rdquo = rdquo
    def add_rdquo(self, value): self.rdquo.append(value)
    def insert_rdquo_at(self, index, value): self.rdquo.insert(index, value)
    def replace_rdquo_at(self, index, value): self.rdquo[index] = value
    def get_bdquo(self): return self.bdquo
    def set_bdquo(self, bdquo): self.bdquo = bdquo
    def add_bdquo(self, value): self.bdquo.append(value)
    def insert_bdquo_at(self, index, value): self.bdquo.insert(index, value)
    def replace_bdquo_at(self, index, value): self.bdquo[index] = value
    def get_dagger(self): return self.dagger
    def set_dagger(self, dagger): self.dagger = dagger
    def add_dagger(self, value): self.dagger.append(value)
    def insert_dagger_at(self, index, value): self.dagger.insert(index, value)
    def replace_dagger_at(self, index, value): self.dagger[index] = value
    def get_Dagger(self): return self.Dagger
    def set_Dagger(self, Dagger): self.Dagger = Dagger
    def add_Dagger(self, value): self.Dagger.append(value)
    def insert_Dagger_at(self, index, value): self.Dagger.insert(index, value)
    def replace_Dagger_at(self, index, value): self.Dagger[index] = value
    def get_permil(self): return self.permil
    def set_permil(self, permil): self.permil = permil
    def add_permil(self, value): self.permil.append(value)
    def insert_permil_at(self, index, value): self.permil.insert(index, value)
    def replace_permil_at(self, index, value): self.permil[index] = value
    def get_lsaquo(self): return self.lsaquo
    def set_lsaquo(self, lsaquo): self.lsaquo = lsaquo
    def add_lsaquo(self, value): self.lsaquo.append(value)
    def insert_lsaquo_at(self, index, value): self.lsaquo.insert(index, value)
    def replace_lsaquo_at(self, index, value): self.lsaquo[index] = value
    def get_rsaquo(self): return self.rsaquo
    def set_rsaquo(self, rsaquo): self.rsaquo = rsaquo
    def add_rsaquo(self, value): self.rsaquo.append(value)
    def insert_rsaquo_at(self, index, value): self.rsaquo.insert(index, value)
    def replace_rsaquo_at(self, index, value): self.rsaquo[index] = value
    def get_euro(self): return self.euro
    def set_euro(self, euro): self.euro = euro
    def add_euro(self, value): self.euro.append(value)
    def insert_euro_at(self, index, value): self.euro.insert(index, value)
    def replace_euro_at(self, index, value): self.euro[index] = value
    def get_tm(self): return self.tm
    def set_tm(self, tm): self.tm = tm
    def add_tm(self, value): self.tm.append(value)
    def insert_tm_at(self, index, value): self.tm.insert(index, value)
    def replace_tm_at(self, index, value): self.tm[index] = value
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ulink or
            self.bold or
            self.emphasis or
            self.computeroutput or
            self.subscript or
            self.superscript or
            self.center or
            self.small or
            self.htmlonly or
            self.manonly or
            self.xmlonly or
            self.rtfonly or
            self.latexonly or
            self.dot or
            self.plantuml or
            self.anchor or
            self.formula or
            self.ref or
            self.nonbreakablespace or
            self.iexcl or
            self.cent or
            self.pound or
            self.curren or
            self.yen or
            self.brvbar or
            self.sect or
            self.umlaut or
            self.copy or
            self.ordf or
            self.laquo or
            self.not_ or
            self.shy or
            self.registered or
            self.macr or
            self.deg or
            self.plusmn or
            self.sup2 or
            self.sup3 or
            self.acute or
            self.micro or
            self.para or
            self.middot or
            self.cedil or
            self.sup1 or
            self.ordm or
            self.raquo or
            self.frac14 or
            self.frac12 or
            self.frac34 or
            self.iquest or
            self.Agrave or
            self.Aacute or
            self.Acirc or
            self.Atilde or
            self.Aumlaut or
            self.Aring or
            self.AElig or
            self.Ccedil or
            self.Egrave or
            self.Eacute or
            self.Ecirc or
            self.Eumlaut or
            self.Igrave or
            self.Iacute or
            self.Icirc or
            self.Iumlaut or
            self.ETH or
            self.Ntilde or
            self.Ograve or
            self.Oacute or
            self.Ocirc or
            self.Otilde or
            self.Oumlaut or
            self.times or
            self.Oslash or
            self.Ugrave or
            self.Uacute or
            self.Ucirc or
            self.Uumlaut or
            self.Yacute or
            self.THORN or
            self.szlig or
            self.agrave or
            self.aacute or
            self.acirc or
            self.atilde or
            self.aumlaut or
            self.aring or
            self.aelig or
            self.ccedil or
            self.egrave or
            self.eacute or
            self.ecirc or
            self.eumlaut or
            self.igrave or
            self.iacute or
            self.icirc or
            self.iumlaut or
            self.eth or
            self.ntilde or
            self.ograve or
            self.oacute or
            self.ocirc or
            self.otilde or
            self.oumlaut or
            self.divide or
            self.oslash or
            self.ugrave or
            self.uacute or
            self.ucirc or
            self.uumlaut or
            self.yacute or
            self.thorn or
            self.yumlaut or
            self.fnof or
            self.Alpha or
            self.Beta or
            self.Gamma or
            self.Delta or
            self.Epsilon or
            self.Zeta or
            self.Eta or
            self.Theta or
            self.Iota or
            self.Kappa or
            self.Lambda or
            self.Mu or
            self.Nu or
            self.Xi or
            self.Omicron or
            self.Pi or
            self.Rho or
            self.Sigma or
            self.Tau or
            self.Upsilon or
            self.Phi or
            self.Chi or
            self.Psi or
            self.Omega or
            self.alpha or
            self.beta or
            self.gamma or
            self.delta or
            self.epsilon or
            self.zeta or
            self.eta or
            self.theta or
            self.iota or
            self.kappa or
            self.lambda_ or
            self.mu or
            self.nu or
            self.xi or
            self.omicron or
            self.pi or
            self.rho or
            self.sigmaf or
            self.sigma or
            self.tau or
            self.upsilon or
            self.phi or
            self.chi or
            self.psi or
            self.omega or
            self.thetasym or
            self.upsih or
            self.piv or
            self.bull or
            self.hellip or
            self.prime or
            self.Prime or
            self.oline or
            self.frasl or
            self.weierp or
            self.imaginary or
            self.real or
            self.trademark or
            self.alefsym or
            self.larr or
            self.uarr or
            self.rarr or
            self.darr or
            self.harr or
            self.crarr or
            self.lArr or
            self.uArr or
            self.rArr or
            self.dArr or
            self.hArr or
            self.forall or
            self.part or
            self.exist or
            self.empty or
            self.nabla or
            self.isin or
            self.notin or
            self.ni or
            self.prod or
            self.sum or
            self.minus or
            self.lowast or
            self.radic or
            self.prop or
            self.infin or
            self.ang or
            self.and_ or
            self.or_ or
            self.cap or
            self.cup or
            self.int or
            self.there4 or
            self.sim or
            self.cong or
            self.asymp or
            self.ne or
            self.equiv or
            self.le or
            self.ge or
            self.sub or
            self.sup or
            self.nsub or
            self.sube or
            self.supe or
            self.oplus or
            self.otimes or
            self.perp or
            self.sdot or
            self.lceil or
            self.rceil or
            self.lfloor or
            self.rfloor or
            self.lang or
            self.rang or
            self.loz or
            self.spades or
            self.clubs or
            self.hearts or
            self.diams or
            self.OElig or
            self.oelig or
            self.Scaron or
            self.scaron or
            self.Yumlaut or
            self.circ or
            self.tilde or
            self.ensp or
            self.emsp or
            self.thinsp or
            self.zwnj or
            self.zwj or
            self.lrm or
            self.rlm or
            self.ndash or
            self.mdash or
            self.lsquo or
            self.rsquo or
            self.sbquo or
            self.ldquo or
            self.rdquo or
            self.bdquo or
            self.dagger or
            self.Dagger or
            self.permil or
            self.lsaquo or
            self.rsaquo or
            self.euro or
            self.tm or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docTocItemType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTocItemType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docTocItemType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docTocItemType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docTocItemType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docTocItemType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for ulink_ in self.ulink:
            ulink_.export(outfile, level, namespace_, name_='ulink', pretty_print=pretty_print)
        for bold_ in self.bold:
            bold_.export(outfile, level, namespace_, name_='bold', pretty_print=pretty_print)
        for emphasis_ in self.emphasis:
            emphasis_.export(outfile, level, namespace_, name_='emphasis', pretty_print=pretty_print)
        for computeroutput_ in self.computeroutput:
            computeroutput_.export(outfile, level, namespace_, name_='computeroutput', pretty_print=pretty_print)
        for subscript_ in self.subscript:
            subscript_.export(outfile, level, namespace_, name_='subscript', pretty_print=pretty_print)
        for superscript_ in self.superscript:
            superscript_.export(outfile, level, namespace_, name_='superscript', pretty_print=pretty_print)
        for center_ in self.center:
            center_.export(outfile, level, namespace_, name_='center', pretty_print=pretty_print)
        for small_ in self.small:
            small_.export(outfile, level, namespace_, name_='small', pretty_print=pretty_print)
        for htmlonly_ in self.htmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<htmlonly>%s</htmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(htmlonly_), input_name='htmlonly')), eol_))
        for manonly_ in self.manonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<manonly>%s</manonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(manonly_), input_name='manonly')), eol_))
        for xmlonly_ in self.xmlonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xmlonly>%s</xmlonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xmlonly_), input_name='xmlonly')), eol_))
        for rtfonly_ in self.rtfonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<rtfonly>%s</rtfonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(rtfonly_), input_name='rtfonly')), eol_))
        for latexonly_ in self.latexonly:
            showIndent(outfile, level, pretty_print)
            outfile.write('<latexonly>%s</latexonly>%s' % (self.gds_encode(self.gds_format_string(quote_xml(latexonly_), input_name='latexonly')), eol_))
        for dot_ in self.dot:
            showIndent(outfile, level, pretty_print)
            outfile.write('<dot>%s</dot>%s' % (self.gds_encode(self.gds_format_string(quote_xml(dot_), input_name='dot')), eol_))
        for plantuml_ in self.plantuml:
            showIndent(outfile, level, pretty_print)
            outfile.write('<plantuml>%s</plantuml>%s' % (self.gds_encode(self.gds_format_string(quote_xml(plantuml_), input_name='plantuml')), eol_))
        for anchor_ in self.anchor:
            anchor_.export(outfile, level, namespace_, name_='anchor', pretty_print=pretty_print)
        for formula_ in self.formula:
            formula_.export(outfile, level, namespace_, name_='formula', pretty_print=pretty_print)
        for ref_ in self.ref:
            ref_.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
        for nonbreakablespace_ in self.nonbreakablespace:
            nonbreakablespace_.export(outfile, level, namespace_, name_='nonbreakablespace', pretty_print=pretty_print)
        for iexcl_ in self.iexcl:
            iexcl_.export(outfile, level, namespace_, name_='iexcl', pretty_print=pretty_print)
        for cent_ in self.cent:
            cent_.export(outfile, level, namespace_, name_='cent', pretty_print=pretty_print)
        for pound_ in self.pound:
            pound_.export(outfile, level, namespace_, name_='pound', pretty_print=pretty_print)
        for curren_ in self.curren:
            curren_.export(outfile, level, namespace_, name_='curren', pretty_print=pretty_print)
        for yen_ in self.yen:
            yen_.export(outfile, level, namespace_, name_='yen', pretty_print=pretty_print)
        for brvbar_ in self.brvbar:
            brvbar_.export(outfile, level, namespace_, name_='brvbar', pretty_print=pretty_print)
        for sect_ in self.sect:
            sect_.export(outfile, level, namespace_, name_='sect', pretty_print=pretty_print)
        for umlaut_ in self.umlaut:
            umlaut_.export(outfile, level, namespace_, name_='umlaut', pretty_print=pretty_print)
        for copy_ in self.copy:
            copy_.export(outfile, level, namespace_, name_='copy', pretty_print=pretty_print)
        for ordf_ in self.ordf:
            ordf_.export(outfile, level, namespace_, name_='ordf', pretty_print=pretty_print)
        for laquo_ in self.laquo:
            laquo_.export(outfile, level, namespace_, name_='laquo', pretty_print=pretty_print)
        for not_ in self.not_:
            not_.export(outfile, level, namespace_, name_='not', pretty_print=pretty_print)
        for shy_ in self.shy:
            shy_.export(outfile, level, namespace_, name_='shy', pretty_print=pretty_print)
        for registered_ in self.registered:
            registered_.export(outfile, level, namespace_, name_='registered', pretty_print=pretty_print)
        for macr_ in self.macr:
            macr_.export(outfile, level, namespace_, name_='macr', pretty_print=pretty_print)
        for deg_ in self.deg:
            deg_.export(outfile, level, namespace_, name_='deg', pretty_print=pretty_print)
        for plusmn_ in self.plusmn:
            plusmn_.export(outfile, level, namespace_, name_='plusmn', pretty_print=pretty_print)
        for sup2_ in self.sup2:
            sup2_.export(outfile, level, namespace_, name_='sup2', pretty_print=pretty_print)
        for sup3_ in self.sup3:
            sup3_.export(outfile, level, namespace_, name_='sup3', pretty_print=pretty_print)
        for acute_ in self.acute:
            acute_.export(outfile, level, namespace_, name_='acute', pretty_print=pretty_print)
        for micro_ in self.micro:
            micro_.export(outfile, level, namespace_, name_='micro', pretty_print=pretty_print)
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for middot_ in self.middot:
            middot_.export(outfile, level, namespace_, name_='middot', pretty_print=pretty_print)
        for cedil_ in self.cedil:
            cedil_.export(outfile, level, namespace_, name_='cedil', pretty_print=pretty_print)
        for sup1_ in self.sup1:
            sup1_.export(outfile, level, namespace_, name_='sup1', pretty_print=pretty_print)
        for ordm_ in self.ordm:
            ordm_.export(outfile, level, namespace_, name_='ordm', pretty_print=pretty_print)
        for raquo_ in self.raquo:
            raquo_.export(outfile, level, namespace_, name_='raquo', pretty_print=pretty_print)
        for frac14_ in self.frac14:
            frac14_.export(outfile, level, namespace_, name_='frac14', pretty_print=pretty_print)
        for frac12_ in self.frac12:
            frac12_.export(outfile, level, namespace_, name_='frac12', pretty_print=pretty_print)
        for frac34_ in self.frac34:
            frac34_.export(outfile, level, namespace_, name_='frac34', pretty_print=pretty_print)
        for iquest_ in self.iquest:
            iquest_.export(outfile, level, namespace_, name_='iquest', pretty_print=pretty_print)
        for Agrave_ in self.Agrave:
            Agrave_.export(outfile, level, namespace_, name_='Agrave', pretty_print=pretty_print)
        for Aacute_ in self.Aacute:
            Aacute_.export(outfile, level, namespace_, name_='Aacute', pretty_print=pretty_print)
        for Acirc_ in self.Acirc:
            Acirc_.export(outfile, level, namespace_, name_='Acirc', pretty_print=pretty_print)
        for Atilde_ in self.Atilde:
            Atilde_.export(outfile, level, namespace_, name_='Atilde', pretty_print=pretty_print)
        for Aumlaut_ in self.Aumlaut:
            Aumlaut_.export(outfile, level, namespace_, name_='Aumlaut', pretty_print=pretty_print)
        for Aring_ in self.Aring:
            Aring_.export(outfile, level, namespace_, name_='Aring', pretty_print=pretty_print)
        for AElig_ in self.AElig:
            AElig_.export(outfile, level, namespace_, name_='AElig', pretty_print=pretty_print)
        for Ccedil_ in self.Ccedil:
            Ccedil_.export(outfile, level, namespace_, name_='Ccedil', pretty_print=pretty_print)
        for Egrave_ in self.Egrave:
            Egrave_.export(outfile, level, namespace_, name_='Egrave', pretty_print=pretty_print)
        for Eacute_ in self.Eacute:
            Eacute_.export(outfile, level, namespace_, name_='Eacute', pretty_print=pretty_print)
        for Ecirc_ in self.Ecirc:
            Ecirc_.export(outfile, level, namespace_, name_='Ecirc', pretty_print=pretty_print)
        for Eumlaut_ in self.Eumlaut:
            Eumlaut_.export(outfile, level, namespace_, name_='Eumlaut', pretty_print=pretty_print)
        for Igrave_ in self.Igrave:
            Igrave_.export(outfile, level, namespace_, name_='Igrave', pretty_print=pretty_print)
        for Iacute_ in self.Iacute:
            Iacute_.export(outfile, level, namespace_, name_='Iacute', pretty_print=pretty_print)
        for Icirc_ in self.Icirc:
            Icirc_.export(outfile, level, namespace_, name_='Icirc', pretty_print=pretty_print)
        for Iumlaut_ in self.Iumlaut:
            Iumlaut_.export(outfile, level, namespace_, name_='Iumlaut', pretty_print=pretty_print)
        for ETH_ in self.ETH:
            ETH_.export(outfile, level, namespace_, name_='ETH', pretty_print=pretty_print)
        for Ntilde_ in self.Ntilde:
            Ntilde_.export(outfile, level, namespace_, name_='Ntilde', pretty_print=pretty_print)
        for Ograve_ in self.Ograve:
            Ograve_.export(outfile, level, namespace_, name_='Ograve', pretty_print=pretty_print)
        for Oacute_ in self.Oacute:
            Oacute_.export(outfile, level, namespace_, name_='Oacute', pretty_print=pretty_print)
        for Ocirc_ in self.Ocirc:
            Ocirc_.export(outfile, level, namespace_, name_='Ocirc', pretty_print=pretty_print)
        for Otilde_ in self.Otilde:
            Otilde_.export(outfile, level, namespace_, name_='Otilde', pretty_print=pretty_print)
        for Oumlaut_ in self.Oumlaut:
            Oumlaut_.export(outfile, level, namespace_, name_='Oumlaut', pretty_print=pretty_print)
        for times_ in self.times:
            times_.export(outfile, level, namespace_, name_='times', pretty_print=pretty_print)
        for Oslash_ in self.Oslash:
            Oslash_.export(outfile, level, namespace_, name_='Oslash', pretty_print=pretty_print)
        for Ugrave_ in self.Ugrave:
            Ugrave_.export(outfile, level, namespace_, name_='Ugrave', pretty_print=pretty_print)
        for Uacute_ in self.Uacute:
            Uacute_.export(outfile, level, namespace_, name_='Uacute', pretty_print=pretty_print)
        for Ucirc_ in self.Ucirc:
            Ucirc_.export(outfile, level, namespace_, name_='Ucirc', pretty_print=pretty_print)
        for Uumlaut_ in self.Uumlaut:
            Uumlaut_.export(outfile, level, namespace_, name_='Uumlaut', pretty_print=pretty_print)
        for Yacute_ in self.Yacute:
            Yacute_.export(outfile, level, namespace_, name_='Yacute', pretty_print=pretty_print)
        for THORN_ in self.THORN:
            THORN_.export(outfile, level, namespace_, name_='THORN', pretty_print=pretty_print)
        for szlig_ in self.szlig:
            szlig_.export(outfile, level, namespace_, name_='szlig', pretty_print=pretty_print)
        for agrave_ in self.agrave:
            agrave_.export(outfile, level, namespace_, name_='agrave', pretty_print=pretty_print)
        for aacute_ in self.aacute:
            aacute_.export(outfile, level, namespace_, name_='aacute', pretty_print=pretty_print)
        for acirc_ in self.acirc:
            acirc_.export(outfile, level, namespace_, name_='acirc', pretty_print=pretty_print)
        for atilde_ in self.atilde:
            atilde_.export(outfile, level, namespace_, name_='atilde', pretty_print=pretty_print)
        for aumlaut_ in self.aumlaut:
            aumlaut_.export(outfile, level, namespace_, name_='aumlaut', pretty_print=pretty_print)
        for aring_ in self.aring:
            aring_.export(outfile, level, namespace_, name_='aring', pretty_print=pretty_print)
        for aelig_ in self.aelig:
            aelig_.export(outfile, level, namespace_, name_='aelig', pretty_print=pretty_print)
        for ccedil_ in self.ccedil:
            ccedil_.export(outfile, level, namespace_, name_='ccedil', pretty_print=pretty_print)
        for egrave_ in self.egrave:
            egrave_.export(outfile, level, namespace_, name_='egrave', pretty_print=pretty_print)
        for eacute_ in self.eacute:
            eacute_.export(outfile, level, namespace_, name_='eacute', pretty_print=pretty_print)
        for ecirc_ in self.ecirc:
            ecirc_.export(outfile, level, namespace_, name_='ecirc', pretty_print=pretty_print)
        for eumlaut_ in self.eumlaut:
            eumlaut_.export(outfile, level, namespace_, name_='eumlaut', pretty_print=pretty_print)
        for igrave_ in self.igrave:
            igrave_.export(outfile, level, namespace_, name_='igrave', pretty_print=pretty_print)
        for iacute_ in self.iacute:
            iacute_.export(outfile, level, namespace_, name_='iacute', pretty_print=pretty_print)
        for icirc_ in self.icirc:
            icirc_.export(outfile, level, namespace_, name_='icirc', pretty_print=pretty_print)
        for iumlaut_ in self.iumlaut:
            iumlaut_.export(outfile, level, namespace_, name_='iumlaut', pretty_print=pretty_print)
        for eth_ in self.eth:
            eth_.export(outfile, level, namespace_, name_='eth', pretty_print=pretty_print)
        for ntilde_ in self.ntilde:
            ntilde_.export(outfile, level, namespace_, name_='ntilde', pretty_print=pretty_print)
        for ograve_ in self.ograve:
            ograve_.export(outfile, level, namespace_, name_='ograve', pretty_print=pretty_print)
        for oacute_ in self.oacute:
            oacute_.export(outfile, level, namespace_, name_='oacute', pretty_print=pretty_print)
        for ocirc_ in self.ocirc:
            ocirc_.export(outfile, level, namespace_, name_='ocirc', pretty_print=pretty_print)
        for otilde_ in self.otilde:
            otilde_.export(outfile, level, namespace_, name_='otilde', pretty_print=pretty_print)
        for oumlaut_ in self.oumlaut:
            oumlaut_.export(outfile, level, namespace_, name_='oumlaut', pretty_print=pretty_print)
        for divide_ in self.divide:
            divide_.export(outfile, level, namespace_, name_='divide', pretty_print=pretty_print)
        for oslash_ in self.oslash:
            oslash_.export(outfile, level, namespace_, name_='oslash', pretty_print=pretty_print)
        for ugrave_ in self.ugrave:
            ugrave_.export(outfile, level, namespace_, name_='ugrave', pretty_print=pretty_print)
        for uacute_ in self.uacute:
            uacute_.export(outfile, level, namespace_, name_='uacute', pretty_print=pretty_print)
        for ucirc_ in self.ucirc:
            ucirc_.export(outfile, level, namespace_, name_='ucirc', pretty_print=pretty_print)
        for uumlaut_ in self.uumlaut:
            uumlaut_.export(outfile, level, namespace_, name_='uumlaut', pretty_print=pretty_print)
        for yacute_ in self.yacute:
            yacute_.export(outfile, level, namespace_, name_='yacute', pretty_print=pretty_print)
        for thorn_ in self.thorn:
            thorn_.export(outfile, level, namespace_, name_='thorn', pretty_print=pretty_print)
        for yumlaut_ in self.yumlaut:
            yumlaut_.export(outfile, level, namespace_, name_='yumlaut', pretty_print=pretty_print)
        for fnof_ in self.fnof:
            fnof_.export(outfile, level, namespace_, name_='fnof', pretty_print=pretty_print)
        for Alpha_ in self.Alpha:
            Alpha_.export(outfile, level, namespace_, name_='Alpha', pretty_print=pretty_print)
        for Beta_ in self.Beta:
            Beta_.export(outfile, level, namespace_, name_='Beta', pretty_print=pretty_print)
        for Gamma_ in self.Gamma:
            Gamma_.export(outfile, level, namespace_, name_='Gamma', pretty_print=pretty_print)
        for Delta_ in self.Delta:
            Delta_.export(outfile, level, namespace_, name_='Delta', pretty_print=pretty_print)
        for Epsilon_ in self.Epsilon:
            Epsilon_.export(outfile, level, namespace_, name_='Epsilon', pretty_print=pretty_print)
        for Zeta_ in self.Zeta:
            Zeta_.export(outfile, level, namespace_, name_='Zeta', pretty_print=pretty_print)
        for Eta_ in self.Eta:
            Eta_.export(outfile, level, namespace_, name_='Eta', pretty_print=pretty_print)
        for Theta_ in self.Theta:
            Theta_.export(outfile, level, namespace_, name_='Theta', pretty_print=pretty_print)
        for Iota_ in self.Iota:
            Iota_.export(outfile, level, namespace_, name_='Iota', pretty_print=pretty_print)
        for Kappa_ in self.Kappa:
            Kappa_.export(outfile, level, namespace_, name_='Kappa', pretty_print=pretty_print)
        for Lambda_ in self.Lambda:
            Lambda_.export(outfile, level, namespace_, name_='Lambda', pretty_print=pretty_print)
        for Mu_ in self.Mu:
            Mu_.export(outfile, level, namespace_, name_='Mu', pretty_print=pretty_print)
        for Nu_ in self.Nu:
            Nu_.export(outfile, level, namespace_, name_='Nu', pretty_print=pretty_print)
        for Xi_ in self.Xi:
            Xi_.export(outfile, level, namespace_, name_='Xi', pretty_print=pretty_print)
        for Omicron_ in self.Omicron:
            Omicron_.export(outfile, level, namespace_, name_='Omicron', pretty_print=pretty_print)
        for Pi_ in self.Pi:
            Pi_.export(outfile, level, namespace_, name_='Pi', pretty_print=pretty_print)
        for Rho_ in self.Rho:
            Rho_.export(outfile, level, namespace_, name_='Rho', pretty_print=pretty_print)
        for Sigma_ in self.Sigma:
            Sigma_.export(outfile, level, namespace_, name_='Sigma', pretty_print=pretty_print)
        for Tau_ in self.Tau:
            Tau_.export(outfile, level, namespace_, name_='Tau', pretty_print=pretty_print)
        for Upsilon_ in self.Upsilon:
            Upsilon_.export(outfile, level, namespace_, name_='Upsilon', pretty_print=pretty_print)
        for Phi_ in self.Phi:
            Phi_.export(outfile, level, namespace_, name_='Phi', pretty_print=pretty_print)
        for Chi_ in self.Chi:
            Chi_.export(outfile, level, namespace_, name_='Chi', pretty_print=pretty_print)
        for Psi_ in self.Psi:
            Psi_.export(outfile, level, namespace_, name_='Psi', pretty_print=pretty_print)
        for Omega_ in self.Omega:
            Omega_.export(outfile, level, namespace_, name_='Omega', pretty_print=pretty_print)
        for alpha_ in self.alpha:
            alpha_.export(outfile, level, namespace_, name_='alpha', pretty_print=pretty_print)
        for beta_ in self.beta:
            beta_.export(outfile, level, namespace_, name_='beta', pretty_print=pretty_print)
        for gamma_ in self.gamma:
            gamma_.export(outfile, level, namespace_, name_='gamma', pretty_print=pretty_print)
        for delta_ in self.delta:
            delta_.export(outfile, level, namespace_, name_='delta', pretty_print=pretty_print)
        for epsilon_ in self.epsilon:
            epsilon_.export(outfile, level, namespace_, name_='epsilon', pretty_print=pretty_print)
        for zeta_ in self.zeta:
            zeta_.export(outfile, level, namespace_, name_='zeta', pretty_print=pretty_print)
        for eta_ in self.eta:
            eta_.export(outfile, level, namespace_, name_='eta', pretty_print=pretty_print)
        for theta_ in self.theta:
            theta_.export(outfile, level, namespace_, name_='theta', pretty_print=pretty_print)
        for iota_ in self.iota:
            iota_.export(outfile, level, namespace_, name_='iota', pretty_print=pretty_print)
        for kappa_ in self.kappa:
            kappa_.export(outfile, level, namespace_, name_='kappa', pretty_print=pretty_print)
        for lambda_ in self.lambda_:
            lambda_.export(outfile, level, namespace_, name_='lambda', pretty_print=pretty_print)
        for mu_ in self.mu:
            mu_.export(outfile, level, namespace_, name_='mu', pretty_print=pretty_print)
        for nu_ in self.nu:
            nu_.export(outfile, level, namespace_, name_='nu', pretty_print=pretty_print)
        for xi_ in self.xi:
            xi_.export(outfile, level, namespace_, name_='xi', pretty_print=pretty_print)
        for omicron_ in self.omicron:
            omicron_.export(outfile, level, namespace_, name_='omicron', pretty_print=pretty_print)
        for pi_ in self.pi:
            pi_.export(outfile, level, namespace_, name_='pi', pretty_print=pretty_print)
        for rho_ in self.rho:
            rho_.export(outfile, level, namespace_, name_='rho', pretty_print=pretty_print)
        for sigmaf_ in self.sigmaf:
            sigmaf_.export(outfile, level, namespace_, name_='sigmaf', pretty_print=pretty_print)
        for sigma_ in self.sigma:
            sigma_.export(outfile, level, namespace_, name_='sigma', pretty_print=pretty_print)
        for tau_ in self.tau:
            tau_.export(outfile, level, namespace_, name_='tau', pretty_print=pretty_print)
        for upsilon_ in self.upsilon:
            upsilon_.export(outfile, level, namespace_, name_='upsilon', pretty_print=pretty_print)
        for phi_ in self.phi:
            phi_.export(outfile, level, namespace_, name_='phi', pretty_print=pretty_print)
        for chi_ in self.chi:
            chi_.export(outfile, level, namespace_, name_='chi', pretty_print=pretty_print)
        for psi_ in self.psi:
            psi_.export(outfile, level, namespace_, name_='psi', pretty_print=pretty_print)
        for omega_ in self.omega:
            omega_.export(outfile, level, namespace_, name_='omega', pretty_print=pretty_print)
        for thetasym_ in self.thetasym:
            thetasym_.export(outfile, level, namespace_, name_='thetasym', pretty_print=pretty_print)
        for upsih_ in self.upsih:
            upsih_.export(outfile, level, namespace_, name_='upsih', pretty_print=pretty_print)
        for piv_ in self.piv:
            piv_.export(outfile, level, namespace_, name_='piv', pretty_print=pretty_print)
        for bull_ in self.bull:
            bull_.export(outfile, level, namespace_, name_='bull', pretty_print=pretty_print)
        for hellip_ in self.hellip:
            hellip_.export(outfile, level, namespace_, name_='hellip', pretty_print=pretty_print)
        for prime_ in self.prime:
            prime_.export(outfile, level, namespace_, name_='prime', pretty_print=pretty_print)
        for Prime_ in self.Prime:
            Prime_.export(outfile, level, namespace_, name_='Prime', pretty_print=pretty_print)
        for oline_ in self.oline:
            oline_.export(outfile, level, namespace_, name_='oline', pretty_print=pretty_print)
        for frasl_ in self.frasl:
            frasl_.export(outfile, level, namespace_, name_='frasl', pretty_print=pretty_print)
        for weierp_ in self.weierp:
            weierp_.export(outfile, level, namespace_, name_='weierp', pretty_print=pretty_print)
        for imaginary_ in self.imaginary:
            imaginary_.export(outfile, level, namespace_, name_='imaginary', pretty_print=pretty_print)
        for real_ in self.real:
            real_.export(outfile, level, namespace_, name_='real', pretty_print=pretty_print)
        for trademark_ in self.trademark:
            trademark_.export(outfile, level, namespace_, name_='trademark', pretty_print=pretty_print)
        for alefsym_ in self.alefsym:
            alefsym_.export(outfile, level, namespace_, name_='alefsym', pretty_print=pretty_print)
        for larr_ in self.larr:
            larr_.export(outfile, level, namespace_, name_='larr', pretty_print=pretty_print)
        for uarr_ in self.uarr:
            uarr_.export(outfile, level, namespace_, name_='uarr', pretty_print=pretty_print)
        for rarr_ in self.rarr:
            rarr_.export(outfile, level, namespace_, name_='rarr', pretty_print=pretty_print)
        for darr_ in self.darr:
            darr_.export(outfile, level, namespace_, name_='darr', pretty_print=pretty_print)
        for harr_ in self.harr:
            harr_.export(outfile, level, namespace_, name_='harr', pretty_print=pretty_print)
        for crarr_ in self.crarr:
            crarr_.export(outfile, level, namespace_, name_='crarr', pretty_print=pretty_print)
        for lArr_ in self.lArr:
            lArr_.export(outfile, level, namespace_, name_='lArr', pretty_print=pretty_print)
        for uArr_ in self.uArr:
            uArr_.export(outfile, level, namespace_, name_='uArr', pretty_print=pretty_print)
        for rArr_ in self.rArr:
            rArr_.export(outfile, level, namespace_, name_='rArr', pretty_print=pretty_print)
        for dArr_ in self.dArr:
            dArr_.export(outfile, level, namespace_, name_='dArr', pretty_print=pretty_print)
        for hArr_ in self.hArr:
            hArr_.export(outfile, level, namespace_, name_='hArr', pretty_print=pretty_print)
        for forall_ in self.forall:
            forall_.export(outfile, level, namespace_, name_='forall', pretty_print=pretty_print)
        for part_ in self.part:
            part_.export(outfile, level, namespace_, name_='part', pretty_print=pretty_print)
        for exist_ in self.exist:
            exist_.export(outfile, level, namespace_, name_='exist', pretty_print=pretty_print)
        for empty_ in self.empty:
            empty_.export(outfile, level, namespace_, name_='empty', pretty_print=pretty_print)
        for nabla_ in self.nabla:
            nabla_.export(outfile, level, namespace_, name_='nabla', pretty_print=pretty_print)
        for isin_ in self.isin:
            isin_.export(outfile, level, namespace_, name_='isin', pretty_print=pretty_print)
        for notin_ in self.notin:
            notin_.export(outfile, level, namespace_, name_='notin', pretty_print=pretty_print)
        for ni_ in self.ni:
            ni_.export(outfile, level, namespace_, name_='ni', pretty_print=pretty_print)
        for prod_ in self.prod:
            prod_.export(outfile, level, namespace_, name_='prod', pretty_print=pretty_print)
        for sum_ in self.sum:
            sum_.export(outfile, level, namespace_, name_='sum', pretty_print=pretty_print)
        for minus_ in self.minus:
            minus_.export(outfile, level, namespace_, name_='minus', pretty_print=pretty_print)
        for lowast_ in self.lowast:
            lowast_.export(outfile, level, namespace_, name_='lowast', pretty_print=pretty_print)
        for radic_ in self.radic:
            radic_.export(outfile, level, namespace_, name_='radic', pretty_print=pretty_print)
        for prop_ in self.prop:
            prop_.export(outfile, level, namespace_, name_='prop', pretty_print=pretty_print)
        for infin_ in self.infin:
            infin_.export(outfile, level, namespace_, name_='infin', pretty_print=pretty_print)
        for ang_ in self.ang:
            ang_.export(outfile, level, namespace_, name_='ang', pretty_print=pretty_print)
        for and_ in self.and_:
            and_.export(outfile, level, namespace_, name_='and', pretty_print=pretty_print)
        for or_ in self.or_:
            or_.export(outfile, level, namespace_, name_='or', pretty_print=pretty_print)
        for cap_ in self.cap:
            cap_.export(outfile, level, namespace_, name_='cap', pretty_print=pretty_print)
        for cup_ in self.cup:
            cup_.export(outfile, level, namespace_, name_='cup', pretty_print=pretty_print)
        for int_ in self.int:
            int_.export(outfile, level, namespace_, name_='int', pretty_print=pretty_print)
        for there4_ in self.there4:
            there4_.export(outfile, level, namespace_, name_='there4', pretty_print=pretty_print)
        for sim_ in self.sim:
            sim_.export(outfile, level, namespace_, name_='sim', pretty_print=pretty_print)
        for cong_ in self.cong:
            cong_.export(outfile, level, namespace_, name_='cong', pretty_print=pretty_print)
        for asymp_ in self.asymp:
            asymp_.export(outfile, level, namespace_, name_='asymp', pretty_print=pretty_print)
        for ne_ in self.ne:
            ne_.export(outfile, level, namespace_, name_='ne', pretty_print=pretty_print)
        for equiv_ in self.equiv:
            equiv_.export(outfile, level, namespace_, name_='equiv', pretty_print=pretty_print)
        for le_ in self.le:
            le_.export(outfile, level, namespace_, name_='le', pretty_print=pretty_print)
        for ge_ in self.ge:
            ge_.export(outfile, level, namespace_, name_='ge', pretty_print=pretty_print)
        for sub_ in self.sub:
            sub_.export(outfile, level, namespace_, name_='sub', pretty_print=pretty_print)
        for sup_ in self.sup:
            sup_.export(outfile, level, namespace_, name_='sup', pretty_print=pretty_print)
        for nsub_ in self.nsub:
            nsub_.export(outfile, level, namespace_, name_='nsub', pretty_print=pretty_print)
        for sube_ in self.sube:
            sube_.export(outfile, level, namespace_, name_='sube', pretty_print=pretty_print)
        for supe_ in self.supe:
            supe_.export(outfile, level, namespace_, name_='supe', pretty_print=pretty_print)
        for oplus_ in self.oplus:
            oplus_.export(outfile, level, namespace_, name_='oplus', pretty_print=pretty_print)
        for otimes_ in self.otimes:
            otimes_.export(outfile, level, namespace_, name_='otimes', pretty_print=pretty_print)
        for perp_ in self.perp:
            perp_.export(outfile, level, namespace_, name_='perp', pretty_print=pretty_print)
        for sdot_ in self.sdot:
            sdot_.export(outfile, level, namespace_, name_='sdot', pretty_print=pretty_print)
        for lceil_ in self.lceil:
            lceil_.export(outfile, level, namespace_, name_='lceil', pretty_print=pretty_print)
        for rceil_ in self.rceil:
            rceil_.export(outfile, level, namespace_, name_='rceil', pretty_print=pretty_print)
        for lfloor_ in self.lfloor:
            lfloor_.export(outfile, level, namespace_, name_='lfloor', pretty_print=pretty_print)
        for rfloor_ in self.rfloor:
            rfloor_.export(outfile, level, namespace_, name_='rfloor', pretty_print=pretty_print)
        for lang_ in self.lang:
            lang_.export(outfile, level, namespace_, name_='lang', pretty_print=pretty_print)
        for rang_ in self.rang:
            rang_.export(outfile, level, namespace_, name_='rang', pretty_print=pretty_print)
        for loz_ in self.loz:
            loz_.export(outfile, level, namespace_, name_='loz', pretty_print=pretty_print)
        for spades_ in self.spades:
            spades_.export(outfile, level, namespace_, name_='spades', pretty_print=pretty_print)
        for clubs_ in self.clubs:
            clubs_.export(outfile, level, namespace_, name_='clubs', pretty_print=pretty_print)
        for hearts_ in self.hearts:
            hearts_.export(outfile, level, namespace_, name_='hearts', pretty_print=pretty_print)
        for diams_ in self.diams:
            diams_.export(outfile, level, namespace_, name_='diams', pretty_print=pretty_print)
        for OElig_ in self.OElig:
            OElig_.export(outfile, level, namespace_, name_='OElig', pretty_print=pretty_print)
        for oelig_ in self.oelig:
            oelig_.export(outfile, level, namespace_, name_='oelig', pretty_print=pretty_print)
        for Scaron_ in self.Scaron:
            Scaron_.export(outfile, level, namespace_, name_='Scaron', pretty_print=pretty_print)
        for scaron_ in self.scaron:
            scaron_.export(outfile, level, namespace_, name_='scaron', pretty_print=pretty_print)
        for Yumlaut_ in self.Yumlaut:
            Yumlaut_.export(outfile, level, namespace_, name_='Yumlaut', pretty_print=pretty_print)
        for circ_ in self.circ:
            circ_.export(outfile, level, namespace_, name_='circ', pretty_print=pretty_print)
        for tilde_ in self.tilde:
            tilde_.export(outfile, level, namespace_, name_='tilde', pretty_print=pretty_print)
        for ensp_ in self.ensp:
            ensp_.export(outfile, level, namespace_, name_='ensp', pretty_print=pretty_print)
        for emsp_ in self.emsp:
            emsp_.export(outfile, level, namespace_, name_='emsp', pretty_print=pretty_print)
        for thinsp_ in self.thinsp:
            thinsp_.export(outfile, level, namespace_, name_='thinsp', pretty_print=pretty_print)
        for zwnj_ in self.zwnj:
            zwnj_.export(outfile, level, namespace_, name_='zwnj', pretty_print=pretty_print)
        for zwj_ in self.zwj:
            zwj_.export(outfile, level, namespace_, name_='zwj', pretty_print=pretty_print)
        for lrm_ in self.lrm:
            lrm_.export(outfile, level, namespace_, name_='lrm', pretty_print=pretty_print)
        for rlm_ in self.rlm:
            rlm_.export(outfile, level, namespace_, name_='rlm', pretty_print=pretty_print)
        for ndash_ in self.ndash:
            ndash_.export(outfile, level, namespace_, name_='ndash', pretty_print=pretty_print)
        for mdash_ in self.mdash:
            mdash_.export(outfile, level, namespace_, name_='mdash', pretty_print=pretty_print)
        for lsquo_ in self.lsquo:
            lsquo_.export(outfile, level, namespace_, name_='lsquo', pretty_print=pretty_print)
        for rsquo_ in self.rsquo:
            rsquo_.export(outfile, level, namespace_, name_='rsquo', pretty_print=pretty_print)
        for sbquo_ in self.sbquo:
            sbquo_.export(outfile, level, namespace_, name_='sbquo', pretty_print=pretty_print)
        for ldquo_ in self.ldquo:
            ldquo_.export(outfile, level, namespace_, name_='ldquo', pretty_print=pretty_print)
        for rdquo_ in self.rdquo:
            rdquo_.export(outfile, level, namespace_, name_='rdquo', pretty_print=pretty_print)
        for bdquo_ in self.bdquo:
            bdquo_.export(outfile, level, namespace_, name_='bdquo', pretty_print=pretty_print)
        for dagger_ in self.dagger:
            dagger_.export(outfile, level, namespace_, name_='dagger', pretty_print=pretty_print)
        for Dagger_ in self.Dagger:
            Dagger_.export(outfile, level, namespace_, name_='Dagger', pretty_print=pretty_print)
        for permil_ in self.permil:
            permil_.export(outfile, level, namespace_, name_='permil', pretty_print=pretty_print)
        for lsaquo_ in self.lsaquo:
            lsaquo_.export(outfile, level, namespace_, name_='lsaquo', pretty_print=pretty_print)
        for rsaquo_ in self.rsaquo:
            rsaquo_.export(outfile, level, namespace_, name_='rsaquo', pretty_print=pretty_print)
        for euro_ in self.euro:
            euro_.export(outfile, level, namespace_, name_='euro', pretty_print=pretty_print)
        for tm_ in self.tm:
            tm_.export(outfile, level, namespace_, name_='tm', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ulink':
            obj_ = docURLLink.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ulink', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ulink'):
              self.add_ulink(obj_.value)
            elif hasattr(self, 'set_ulink'):
              self.set_ulink(obj_.value)
        elif nodeName_ == 'bold':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bold', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bold'):
              self.add_bold(obj_.value)
            elif hasattr(self, 'set_bold'):
              self.set_bold(obj_.value)
        elif nodeName_ == 'emphasis':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emphasis', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emphasis'):
              self.add_emphasis(obj_.value)
            elif hasattr(self, 'set_emphasis'):
              self.set_emphasis(obj_.value)
        elif nodeName_ == 'computeroutput':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'computeroutput', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_computeroutput'):
              self.add_computeroutput(obj_.value)
            elif hasattr(self, 'set_computeroutput'):
              self.set_computeroutput(obj_.value)
        elif nodeName_ == 'subscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'subscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_subscript'):
              self.add_subscript(obj_.value)
            elif hasattr(self, 'set_subscript'):
              self.set_subscript(obj_.value)
        elif nodeName_ == 'superscript':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'superscript', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_superscript'):
              self.add_superscript(obj_.value)
            elif hasattr(self, 'set_superscript'):
              self.set_superscript(obj_.value)
        elif nodeName_ == 'center':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'center', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_center'):
              self.add_center(obj_.value)
            elif hasattr(self, 'set_center'):
              self.set_center(obj_.value)
        elif nodeName_ == 'small':
            obj_ = docMarkupType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'small', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_small'):
              self.add_small(obj_.value)
            elif hasattr(self, 'set_small'):
              self.set_small(obj_.value)
        elif nodeName_ == 'htmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'htmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'manonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'manonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'xmlonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'xmlonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'rtfonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'rtfonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'latexonly' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'latexonly', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'dot' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'dot', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'plantuml' and child_.text is not None:
            valuestr_ = child_.text
            obj_ = self.mixedclass_(MixedContainer.CategorySimple,
                MixedContainer.TypeString, 'plantuml', valuestr_)
            self.content_.append(obj_)
        elif nodeName_ == 'anchor':
            obj_ = docAnchorType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'anchor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_anchor'):
              self.add_anchor(obj_.value)
            elif hasattr(self, 'set_anchor'):
              self.set_anchor(obj_.value)
        elif nodeName_ == 'formula':
            obj_ = docFormulaType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'formula', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_formula'):
              self.add_formula(obj_.value)
            elif hasattr(self, 'set_formula'):
              self.set_formula(obj_.value)
        elif nodeName_ == 'ref':
            obj_ = docRefTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        elif nodeName_ == 'nonbreakablespace':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nonbreakablespace', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nonbreakablespace'):
              self.add_nonbreakablespace(obj_.value)
            elif hasattr(self, 'set_nonbreakablespace'):
              self.set_nonbreakablespace(obj_.value)
        elif nodeName_ == 'iexcl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iexcl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iexcl'):
              self.add_iexcl(obj_.value)
            elif hasattr(self, 'set_iexcl'):
              self.set_iexcl(obj_.value)
        elif nodeName_ == 'cent':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cent', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cent'):
              self.add_cent(obj_.value)
            elif hasattr(self, 'set_cent'):
              self.set_cent(obj_.value)
        elif nodeName_ == 'pound':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pound', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pound'):
              self.add_pound(obj_.value)
            elif hasattr(self, 'set_pound'):
              self.set_pound(obj_.value)
        elif nodeName_ == 'curren':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'curren', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_curren'):
              self.add_curren(obj_.value)
            elif hasattr(self, 'set_curren'):
              self.set_curren(obj_.value)
        elif nodeName_ == 'yen':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yen', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yen'):
              self.add_yen(obj_.value)
            elif hasattr(self, 'set_yen'):
              self.set_yen(obj_.value)
        elif nodeName_ == 'brvbar':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'brvbar', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_brvbar'):
              self.add_brvbar(obj_.value)
            elif hasattr(self, 'set_brvbar'):
              self.set_brvbar(obj_.value)
        elif nodeName_ == 'sect':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sect', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sect'):
              self.add_sect(obj_.value)
            elif hasattr(self, 'set_sect'):
              self.set_sect(obj_.value)
        elif nodeName_ == 'umlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'umlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_umlaut'):
              self.add_umlaut(obj_.value)
            elif hasattr(self, 'set_umlaut'):
              self.set_umlaut(obj_.value)
        elif nodeName_ == 'copy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'copy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_copy'):
              self.add_copy(obj_.value)
            elif hasattr(self, 'set_copy'):
              self.set_copy(obj_.value)
        elif nodeName_ == 'ordf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordf'):
              self.add_ordf(obj_.value)
            elif hasattr(self, 'set_ordf'):
              self.set_ordf(obj_.value)
        elif nodeName_ == 'laquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'laquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_laquo'):
              self.add_laquo(obj_.value)
            elif hasattr(self, 'set_laquo'):
              self.set_laquo(obj_.value)
        elif nodeName_ == 'not':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'not', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_not'):
              self.add_not(obj_.value)
            elif hasattr(self, 'set_not'):
              self.set_not(obj_.value)
        elif nodeName_ == 'shy':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'shy', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_shy'):
              self.add_shy(obj_.value)
            elif hasattr(self, 'set_shy'):
              self.set_shy(obj_.value)
        elif nodeName_ == 'registered':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'registered', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_registered'):
              self.add_registered(obj_.value)
            elif hasattr(self, 'set_registered'):
              self.set_registered(obj_.value)
        elif nodeName_ == 'macr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'macr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_macr'):
              self.add_macr(obj_.value)
            elif hasattr(self, 'set_macr'):
              self.set_macr(obj_.value)
        elif nodeName_ == 'deg':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'deg', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_deg'):
              self.add_deg(obj_.value)
            elif hasattr(self, 'set_deg'):
              self.set_deg(obj_.value)
        elif nodeName_ == 'plusmn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'plusmn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_plusmn'):
              self.add_plusmn(obj_.value)
            elif hasattr(self, 'set_plusmn'):
              self.set_plusmn(obj_.value)
        elif nodeName_ == 'sup2':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup2', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup2'):
              self.add_sup2(obj_.value)
            elif hasattr(self, 'set_sup2'):
              self.set_sup2(obj_.value)
        elif nodeName_ == 'sup3':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup3', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup3'):
              self.add_sup3(obj_.value)
            elif hasattr(self, 'set_sup3'):
              self.set_sup3(obj_.value)
        elif nodeName_ == 'acute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acute'):
              self.add_acute(obj_.value)
            elif hasattr(self, 'set_acute'):
              self.set_acute(obj_.value)
        elif nodeName_ == 'micro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'micro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_micro'):
              self.add_micro(obj_.value)
            elif hasattr(self, 'set_micro'):
              self.set_micro(obj_.value)
        elif nodeName_ == 'para':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'para', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_para'):
              self.add_para(obj_.value)
            elif hasattr(self, 'set_para'):
              self.set_para(obj_.value)
        elif nodeName_ == 'middot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'middot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_middot'):
              self.add_middot(obj_.value)
            elif hasattr(self, 'set_middot'):
              self.set_middot(obj_.value)
        elif nodeName_ == 'cedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cedil'):
              self.add_cedil(obj_.value)
            elif hasattr(self, 'set_cedil'):
              self.set_cedil(obj_.value)
        elif nodeName_ == 'sup1':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup1', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup1'):
              self.add_sup1(obj_.value)
            elif hasattr(self, 'set_sup1'):
              self.set_sup1(obj_.value)
        elif nodeName_ == 'ordm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ordm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ordm'):
              self.add_ordm(obj_.value)
            elif hasattr(self, 'set_ordm'):
              self.set_ordm(obj_.value)
        elif nodeName_ == 'raquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'raquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_raquo'):
              self.add_raquo(obj_.value)
            elif hasattr(self, 'set_raquo'):
              self.set_raquo(obj_.value)
        elif nodeName_ == 'frac14':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac14', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac14'):
              self.add_frac14(obj_.value)
            elif hasattr(self, 'set_frac14'):
              self.set_frac14(obj_.value)
        elif nodeName_ == 'frac12':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac12', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac12'):
              self.add_frac12(obj_.value)
            elif hasattr(self, 'set_frac12'):
              self.set_frac12(obj_.value)
        elif nodeName_ == 'frac34':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frac34', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frac34'):
              self.add_frac34(obj_.value)
            elif hasattr(self, 'set_frac34'):
              self.set_frac34(obj_.value)
        elif nodeName_ == 'iquest':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iquest', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iquest'):
              self.add_iquest(obj_.value)
            elif hasattr(self, 'set_iquest'):
              self.set_iquest(obj_.value)
        elif nodeName_ == 'Agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Agrave'):
              self.add_Agrave(obj_.value)
            elif hasattr(self, 'set_Agrave'):
              self.set_Agrave(obj_.value)
        elif nodeName_ == 'Aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aacute'):
              self.add_Aacute(obj_.value)
            elif hasattr(self, 'set_Aacute'):
              self.set_Aacute(obj_.value)
        elif nodeName_ == 'Acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Acirc'):
              self.add_Acirc(obj_.value)
            elif hasattr(self, 'set_Acirc'):
              self.set_Acirc(obj_.value)
        elif nodeName_ == 'Atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Atilde'):
              self.add_Atilde(obj_.value)
            elif hasattr(self, 'set_Atilde'):
              self.set_Atilde(obj_.value)
        elif nodeName_ == 'Aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aumlaut'):
              self.add_Aumlaut(obj_.value)
            elif hasattr(self, 'set_Aumlaut'):
              self.set_Aumlaut(obj_.value)
        elif nodeName_ == 'Aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Aring'):
              self.add_Aring(obj_.value)
            elif hasattr(self, 'set_Aring'):
              self.set_Aring(obj_.value)
        elif nodeName_ == 'AElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'AElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_AElig'):
              self.add_AElig(obj_.value)
            elif hasattr(self, 'set_AElig'):
              self.set_AElig(obj_.value)
        elif nodeName_ == 'Ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ccedil'):
              self.add_Ccedil(obj_.value)
            elif hasattr(self, 'set_Ccedil'):
              self.set_Ccedil(obj_.value)
        elif nodeName_ == 'Egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Egrave'):
              self.add_Egrave(obj_.value)
            elif hasattr(self, 'set_Egrave'):
              self.set_Egrave(obj_.value)
        elif nodeName_ == 'Eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eacute'):
              self.add_Eacute(obj_.value)
            elif hasattr(self, 'set_Eacute'):
              self.set_Eacute(obj_.value)
        elif nodeName_ == 'Ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ecirc'):
              self.add_Ecirc(obj_.value)
            elif hasattr(self, 'set_Ecirc'):
              self.set_Ecirc(obj_.value)
        elif nodeName_ == 'Eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eumlaut'):
              self.add_Eumlaut(obj_.value)
            elif hasattr(self, 'set_Eumlaut'):
              self.set_Eumlaut(obj_.value)
        elif nodeName_ == 'Igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Igrave'):
              self.add_Igrave(obj_.value)
            elif hasattr(self, 'set_Igrave'):
              self.set_Igrave(obj_.value)
        elif nodeName_ == 'Iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iacute'):
              self.add_Iacute(obj_.value)
            elif hasattr(self, 'set_Iacute'):
              self.set_Iacute(obj_.value)
        elif nodeName_ == 'Icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Icirc'):
              self.add_Icirc(obj_.value)
            elif hasattr(self, 'set_Icirc'):
              self.set_Icirc(obj_.value)
        elif nodeName_ == 'Iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iumlaut'):
              self.add_Iumlaut(obj_.value)
            elif hasattr(self, 'set_Iumlaut'):
              self.set_Iumlaut(obj_.value)
        elif nodeName_ == 'ETH':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ETH', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ETH'):
              self.add_ETH(obj_.value)
            elif hasattr(self, 'set_ETH'):
              self.set_ETH(obj_.value)
        elif nodeName_ == 'Ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ntilde'):
              self.add_Ntilde(obj_.value)
            elif hasattr(self, 'set_Ntilde'):
              self.set_Ntilde(obj_.value)
        elif nodeName_ == 'Ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ograve'):
              self.add_Ograve(obj_.value)
            elif hasattr(self, 'set_Ograve'):
              self.set_Ograve(obj_.value)
        elif nodeName_ == 'Oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oacute'):
              self.add_Oacute(obj_.value)
            elif hasattr(self, 'set_Oacute'):
              self.set_Oacute(obj_.value)
        elif nodeName_ == 'Ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ocirc'):
              self.add_Ocirc(obj_.value)
            elif hasattr(self, 'set_Ocirc'):
              self.set_Ocirc(obj_.value)
        elif nodeName_ == 'Otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Otilde'):
              self.add_Otilde(obj_.value)
            elif hasattr(self, 'set_Otilde'):
              self.set_Otilde(obj_.value)
        elif nodeName_ == 'Oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oumlaut'):
              self.add_Oumlaut(obj_.value)
            elif hasattr(self, 'set_Oumlaut'):
              self.set_Oumlaut(obj_.value)
        elif nodeName_ == 'times':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'times', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_times'):
              self.add_times(obj_.value)
            elif hasattr(self, 'set_times'):
              self.set_times(obj_.value)
        elif nodeName_ == 'Oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Oslash'):
              self.add_Oslash(obj_.value)
            elif hasattr(self, 'set_Oslash'):
              self.set_Oslash(obj_.value)
        elif nodeName_ == 'Ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ugrave'):
              self.add_Ugrave(obj_.value)
            elif hasattr(self, 'set_Ugrave'):
              self.set_Ugrave(obj_.value)
        elif nodeName_ == 'Uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uacute'):
              self.add_Uacute(obj_.value)
            elif hasattr(self, 'set_Uacute'):
              self.set_Uacute(obj_.value)
        elif nodeName_ == 'Ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Ucirc'):
              self.add_Ucirc(obj_.value)
            elif hasattr(self, 'set_Ucirc'):
              self.set_Ucirc(obj_.value)
        elif nodeName_ == 'Uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Uumlaut'):
              self.add_Uumlaut(obj_.value)
            elif hasattr(self, 'set_Uumlaut'):
              self.set_Uumlaut(obj_.value)
        elif nodeName_ == 'Yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yacute'):
              self.add_Yacute(obj_.value)
            elif hasattr(self, 'set_Yacute'):
              self.set_Yacute(obj_.value)
        elif nodeName_ == 'THORN':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'THORN', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_THORN'):
              self.add_THORN(obj_.value)
            elif hasattr(self, 'set_THORN'):
              self.set_THORN(obj_.value)
        elif nodeName_ == 'szlig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'szlig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_szlig'):
              self.add_szlig(obj_.value)
            elif hasattr(self, 'set_szlig'):
              self.set_szlig(obj_.value)
        elif nodeName_ == 'agrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'agrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_agrave'):
              self.add_agrave(obj_.value)
            elif hasattr(self, 'set_agrave'):
              self.set_agrave(obj_.value)
        elif nodeName_ == 'aacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aacute'):
              self.add_aacute(obj_.value)
            elif hasattr(self, 'set_aacute'):
              self.set_aacute(obj_.value)
        elif nodeName_ == 'acirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'acirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_acirc'):
              self.add_acirc(obj_.value)
            elif hasattr(self, 'set_acirc'):
              self.set_acirc(obj_.value)
        elif nodeName_ == 'atilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'atilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_atilde'):
              self.add_atilde(obj_.value)
            elif hasattr(self, 'set_atilde'):
              self.set_atilde(obj_.value)
        elif nodeName_ == 'aumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aumlaut'):
              self.add_aumlaut(obj_.value)
            elif hasattr(self, 'set_aumlaut'):
              self.set_aumlaut(obj_.value)
        elif nodeName_ == 'aring':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aring', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aring'):
              self.add_aring(obj_.value)
            elif hasattr(self, 'set_aring'):
              self.set_aring(obj_.value)
        elif nodeName_ == 'aelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'aelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_aelig'):
              self.add_aelig(obj_.value)
            elif hasattr(self, 'set_aelig'):
              self.set_aelig(obj_.value)
        elif nodeName_ == 'ccedil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ccedil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ccedil'):
              self.add_ccedil(obj_.value)
            elif hasattr(self, 'set_ccedil'):
              self.set_ccedil(obj_.value)
        elif nodeName_ == 'egrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'egrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_egrave'):
              self.add_egrave(obj_.value)
            elif hasattr(self, 'set_egrave'):
              self.set_egrave(obj_.value)
        elif nodeName_ == 'eacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eacute'):
              self.add_eacute(obj_.value)
            elif hasattr(self, 'set_eacute'):
              self.set_eacute(obj_.value)
        elif nodeName_ == 'ecirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ecirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ecirc'):
              self.add_ecirc(obj_.value)
            elif hasattr(self, 'set_ecirc'):
              self.set_ecirc(obj_.value)
        elif nodeName_ == 'eumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eumlaut'):
              self.add_eumlaut(obj_.value)
            elif hasattr(self, 'set_eumlaut'):
              self.set_eumlaut(obj_.value)
        elif nodeName_ == 'igrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'igrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_igrave'):
              self.add_igrave(obj_.value)
            elif hasattr(self, 'set_igrave'):
              self.set_igrave(obj_.value)
        elif nodeName_ == 'iacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iacute'):
              self.add_iacute(obj_.value)
            elif hasattr(self, 'set_iacute'):
              self.set_iacute(obj_.value)
        elif nodeName_ == 'icirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'icirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_icirc'):
              self.add_icirc(obj_.value)
            elif hasattr(self, 'set_icirc'):
              self.set_icirc(obj_.value)
        elif nodeName_ == 'iumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iumlaut'):
              self.add_iumlaut(obj_.value)
            elif hasattr(self, 'set_iumlaut'):
              self.set_iumlaut(obj_.value)
        elif nodeName_ == 'eth':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eth', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eth'):
              self.add_eth(obj_.value)
            elif hasattr(self, 'set_eth'):
              self.set_eth(obj_.value)
        elif nodeName_ == 'ntilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ntilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ntilde'):
              self.add_ntilde(obj_.value)
            elif hasattr(self, 'set_ntilde'):
              self.set_ntilde(obj_.value)
        elif nodeName_ == 'ograve':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ograve', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ograve'):
              self.add_ograve(obj_.value)
            elif hasattr(self, 'set_ograve'):
              self.set_ograve(obj_.value)
        elif nodeName_ == 'oacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oacute'):
              self.add_oacute(obj_.value)
            elif hasattr(self, 'set_oacute'):
              self.set_oacute(obj_.value)
        elif nodeName_ == 'ocirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ocirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ocirc'):
              self.add_ocirc(obj_.value)
            elif hasattr(self, 'set_ocirc'):
              self.set_ocirc(obj_.value)
        elif nodeName_ == 'otilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otilde'):
              self.add_otilde(obj_.value)
            elif hasattr(self, 'set_otilde'):
              self.set_otilde(obj_.value)
        elif nodeName_ == 'oumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oumlaut'):
              self.add_oumlaut(obj_.value)
            elif hasattr(self, 'set_oumlaut'):
              self.set_oumlaut(obj_.value)
        elif nodeName_ == 'divide':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'divide', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_divide'):
              self.add_divide(obj_.value)
            elif hasattr(self, 'set_divide'):
              self.set_divide(obj_.value)
        elif nodeName_ == 'oslash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oslash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oslash'):
              self.add_oslash(obj_.value)
            elif hasattr(self, 'set_oslash'):
              self.set_oslash(obj_.value)
        elif nodeName_ == 'ugrave':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ugrave', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ugrave'):
              self.add_ugrave(obj_.value)
            elif hasattr(self, 'set_ugrave'):
              self.set_ugrave(obj_.value)
        elif nodeName_ == 'uacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uacute'):
              self.add_uacute(obj_.value)
            elif hasattr(self, 'set_uacute'):
              self.set_uacute(obj_.value)
        elif nodeName_ == 'ucirc':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ucirc', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ucirc'):
              self.add_ucirc(obj_.value)
            elif hasattr(self, 'set_ucirc'):
              self.set_ucirc(obj_.value)
        elif nodeName_ == 'uumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uumlaut'):
              self.add_uumlaut(obj_.value)
            elif hasattr(self, 'set_uumlaut'):
              self.set_uumlaut(obj_.value)
        elif nodeName_ == 'yacute':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yacute', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yacute'):
              self.add_yacute(obj_.value)
            elif hasattr(self, 'set_yacute'):
              self.set_yacute(obj_.value)
        elif nodeName_ == 'thorn':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thorn', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thorn'):
              self.add_thorn(obj_.value)
            elif hasattr(self, 'set_thorn'):
              self.set_thorn(obj_.value)
        elif nodeName_ == 'yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_yumlaut'):
              self.add_yumlaut(obj_.value)
            elif hasattr(self, 'set_yumlaut'):
              self.set_yumlaut(obj_.value)
        elif nodeName_ == 'fnof':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'fnof', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_fnof'):
              self.add_fnof(obj_.value)
            elif hasattr(self, 'set_fnof'):
              self.set_fnof(obj_.value)
        elif nodeName_ == 'Alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Alpha'):
              self.add_Alpha(obj_.value)
            elif hasattr(self, 'set_Alpha'):
              self.set_Alpha(obj_.value)
        elif nodeName_ == 'Beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Beta'):
              self.add_Beta(obj_.value)
            elif hasattr(self, 'set_Beta'):
              self.set_Beta(obj_.value)
        elif nodeName_ == 'Gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Gamma'):
              self.add_Gamma(obj_.value)
            elif hasattr(self, 'set_Gamma'):
              self.set_Gamma(obj_.value)
        elif nodeName_ == 'Delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Delta'):
              self.add_Delta(obj_.value)
            elif hasattr(self, 'set_Delta'):
              self.set_Delta(obj_.value)
        elif nodeName_ == 'Epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Epsilon'):
              self.add_Epsilon(obj_.value)
            elif hasattr(self, 'set_Epsilon'):
              self.set_Epsilon(obj_.value)
        elif nodeName_ == 'Zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Zeta'):
              self.add_Zeta(obj_.value)
            elif hasattr(self, 'set_Zeta'):
              self.set_Zeta(obj_.value)
        elif nodeName_ == 'Eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Eta'):
              self.add_Eta(obj_.value)
            elif hasattr(self, 'set_Eta'):
              self.set_Eta(obj_.value)
        elif nodeName_ == 'Theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Theta'):
              self.add_Theta(obj_.value)
            elif hasattr(self, 'set_Theta'):
              self.set_Theta(obj_.value)
        elif nodeName_ == 'Iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Iota'):
              self.add_Iota(obj_.value)
            elif hasattr(self, 'set_Iota'):
              self.set_Iota(obj_.value)
        elif nodeName_ == 'Kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Kappa'):
              self.add_Kappa(obj_.value)
            elif hasattr(self, 'set_Kappa'):
              self.set_Kappa(obj_.value)
        elif nodeName_ == 'Lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Lambda'):
              self.add_Lambda(obj_.value)
            elif hasattr(self, 'set_Lambda'):
              self.set_Lambda(obj_.value)
        elif nodeName_ == 'Mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Mu'):
              self.add_Mu(obj_.value)
            elif hasattr(self, 'set_Mu'):
              self.set_Mu(obj_.value)
        elif nodeName_ == 'Nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Nu'):
              self.add_Nu(obj_.value)
            elif hasattr(self, 'set_Nu'):
              self.set_Nu(obj_.value)
        elif nodeName_ == 'Xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Xi'):
              self.add_Xi(obj_.value)
            elif hasattr(self, 'set_Xi'):
              self.set_Xi(obj_.value)
        elif nodeName_ == 'Omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omicron'):
              self.add_Omicron(obj_.value)
            elif hasattr(self, 'set_Omicron'):
              self.set_Omicron(obj_.value)
        elif nodeName_ == 'Pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Pi'):
              self.add_Pi(obj_.value)
            elif hasattr(self, 'set_Pi'):
              self.set_Pi(obj_.value)
        elif nodeName_ == 'Rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Rho'):
              self.add_Rho(obj_.value)
            elif hasattr(self, 'set_Rho'):
              self.set_Rho(obj_.value)
        elif nodeName_ == 'Sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Sigma'):
              self.add_Sigma(obj_.value)
            elif hasattr(self, 'set_Sigma'):
              self.set_Sigma(obj_.value)
        elif nodeName_ == 'Tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Tau'):
              self.add_Tau(obj_.value)
            elif hasattr(self, 'set_Tau'):
              self.set_Tau(obj_.value)
        elif nodeName_ == 'Upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Upsilon'):
              self.add_Upsilon(obj_.value)
            elif hasattr(self, 'set_Upsilon'):
              self.set_Upsilon(obj_.value)
        elif nodeName_ == 'Phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Phi'):
              self.add_Phi(obj_.value)
            elif hasattr(self, 'set_Phi'):
              self.set_Phi(obj_.value)
        elif nodeName_ == 'Chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Chi'):
              self.add_Chi(obj_.value)
            elif hasattr(self, 'set_Chi'):
              self.set_Chi(obj_.value)
        elif nodeName_ == 'Psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Psi'):
              self.add_Psi(obj_.value)
            elif hasattr(self, 'set_Psi'):
              self.set_Psi(obj_.value)
        elif nodeName_ == 'Omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Omega'):
              self.add_Omega(obj_.value)
            elif hasattr(self, 'set_Omega'):
              self.set_Omega(obj_.value)
        elif nodeName_ == 'alpha':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alpha', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alpha'):
              self.add_alpha(obj_.value)
            elif hasattr(self, 'set_alpha'):
              self.set_alpha(obj_.value)
        elif nodeName_ == 'beta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'beta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_beta'):
              self.add_beta(obj_.value)
            elif hasattr(self, 'set_beta'):
              self.set_beta(obj_.value)
        elif nodeName_ == 'gamma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'gamma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_gamma'):
              self.add_gamma(obj_.value)
            elif hasattr(self, 'set_gamma'):
              self.set_gamma(obj_.value)
        elif nodeName_ == 'delta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'delta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_delta'):
              self.add_delta(obj_.value)
            elif hasattr(self, 'set_delta'):
              self.set_delta(obj_.value)
        elif nodeName_ == 'epsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'epsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_epsilon'):
              self.add_epsilon(obj_.value)
            elif hasattr(self, 'set_epsilon'):
              self.set_epsilon(obj_.value)
        elif nodeName_ == 'zeta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zeta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zeta'):
              self.add_zeta(obj_.value)
            elif hasattr(self, 'set_zeta'):
              self.set_zeta(obj_.value)
        elif nodeName_ == 'eta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'eta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_eta'):
              self.add_eta(obj_.value)
            elif hasattr(self, 'set_eta'):
              self.set_eta(obj_.value)
        elif nodeName_ == 'theta':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'theta', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_theta'):
              self.add_theta(obj_.value)
            elif hasattr(self, 'set_theta'):
              self.set_theta(obj_.value)
        elif nodeName_ == 'iota':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'iota', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_iota'):
              self.add_iota(obj_.value)
            elif hasattr(self, 'set_iota'):
              self.set_iota(obj_.value)
        elif nodeName_ == 'kappa':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'kappa', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_kappa'):
              self.add_kappa(obj_.value)
            elif hasattr(self, 'set_kappa'):
              self.set_kappa(obj_.value)
        elif nodeName_ == 'lambda':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lambda', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lambda'):
              self.add_lambda(obj_.value)
            elif hasattr(self, 'set_lambda'):
              self.set_lambda(obj_.value)
        elif nodeName_ == 'mu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mu'):
              self.add_mu(obj_.value)
            elif hasattr(self, 'set_mu'):
              self.set_mu(obj_.value)
        elif nodeName_ == 'nu':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nu', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nu'):
              self.add_nu(obj_.value)
            elif hasattr(self, 'set_nu'):
              self.set_nu(obj_.value)
        elif nodeName_ == 'xi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'xi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_xi'):
              self.add_xi(obj_.value)
            elif hasattr(self, 'set_xi'):
              self.set_xi(obj_.value)
        elif nodeName_ == 'omicron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omicron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omicron'):
              self.add_omicron(obj_.value)
            elif hasattr(self, 'set_omicron'):
              self.set_omicron(obj_.value)
        elif nodeName_ == 'pi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'pi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_pi'):
              self.add_pi(obj_.value)
            elif hasattr(self, 'set_pi'):
              self.set_pi(obj_.value)
        elif nodeName_ == 'rho':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rho', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rho'):
              self.add_rho(obj_.value)
            elif hasattr(self, 'set_rho'):
              self.set_rho(obj_.value)
        elif nodeName_ == 'sigmaf':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigmaf', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigmaf'):
              self.add_sigmaf(obj_.value)
            elif hasattr(self, 'set_sigmaf'):
              self.set_sigmaf(obj_.value)
        elif nodeName_ == 'sigma':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sigma', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sigma'):
              self.add_sigma(obj_.value)
            elif hasattr(self, 'set_sigma'):
              self.set_sigma(obj_.value)
        elif nodeName_ == 'tau':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tau', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tau'):
              self.add_tau(obj_.value)
            elif hasattr(self, 'set_tau'):
              self.set_tau(obj_.value)
        elif nodeName_ == 'upsilon':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsilon', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsilon'):
              self.add_upsilon(obj_.value)
            elif hasattr(self, 'set_upsilon'):
              self.set_upsilon(obj_.value)
        elif nodeName_ == 'phi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'phi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_phi'):
              self.add_phi(obj_.value)
            elif hasattr(self, 'set_phi'):
              self.set_phi(obj_.value)
        elif nodeName_ == 'chi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'chi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_chi'):
              self.add_chi(obj_.value)
            elif hasattr(self, 'set_chi'):
              self.set_chi(obj_.value)
        elif nodeName_ == 'psi':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'psi', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_psi'):
              self.add_psi(obj_.value)
            elif hasattr(self, 'set_psi'):
              self.set_psi(obj_.value)
        elif nodeName_ == 'omega':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'omega', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_omega'):
              self.add_omega(obj_.value)
            elif hasattr(self, 'set_omega'):
              self.set_omega(obj_.value)
        elif nodeName_ == 'thetasym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thetasym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thetasym'):
              self.add_thetasym(obj_.value)
            elif hasattr(self, 'set_thetasym'):
              self.set_thetasym(obj_.value)
        elif nodeName_ == 'upsih':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'upsih', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_upsih'):
              self.add_upsih(obj_.value)
            elif hasattr(self, 'set_upsih'):
              self.set_upsih(obj_.value)
        elif nodeName_ == 'piv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'piv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_piv'):
              self.add_piv(obj_.value)
            elif hasattr(self, 'set_piv'):
              self.set_piv(obj_.value)
        elif nodeName_ == 'bull':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bull', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bull'):
              self.add_bull(obj_.value)
            elif hasattr(self, 'set_bull'):
              self.set_bull(obj_.value)
        elif nodeName_ == 'hellip':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hellip', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hellip'):
              self.add_hellip(obj_.value)
            elif hasattr(self, 'set_hellip'):
              self.set_hellip(obj_.value)
        elif nodeName_ == 'prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prime'):
              self.add_prime(obj_.value)
            elif hasattr(self, 'set_prime'):
              self.set_prime(obj_.value)
        elif nodeName_ == 'Prime':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Prime', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Prime'):
              self.add_Prime(obj_.value)
            elif hasattr(self, 'set_Prime'):
              self.set_Prime(obj_.value)
        elif nodeName_ == 'oline':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oline', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oline'):
              self.add_oline(obj_.value)
            elif hasattr(self, 'set_oline'):
              self.set_oline(obj_.value)
        elif nodeName_ == 'frasl':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'frasl', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_frasl'):
              self.add_frasl(obj_.value)
            elif hasattr(self, 'set_frasl'):
              self.set_frasl(obj_.value)
        elif nodeName_ == 'weierp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'weierp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_weierp'):
              self.add_weierp(obj_.value)
            elif hasattr(self, 'set_weierp'):
              self.set_weierp(obj_.value)
        elif nodeName_ == 'imaginary':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'imaginary', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_imaginary'):
              self.add_imaginary(obj_.value)
            elif hasattr(self, 'set_imaginary'):
              self.set_imaginary(obj_.value)
        elif nodeName_ == 'real':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'real', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_real'):
              self.add_real(obj_.value)
            elif hasattr(self, 'set_real'):
              self.set_real(obj_.value)
        elif nodeName_ == 'trademark':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'trademark', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_trademark'):
              self.add_trademark(obj_.value)
            elif hasattr(self, 'set_trademark'):
              self.set_trademark(obj_.value)
        elif nodeName_ == 'alefsym':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'alefsym', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_alefsym'):
              self.add_alefsym(obj_.value)
            elif hasattr(self, 'set_alefsym'):
              self.set_alefsym(obj_.value)
        elif nodeName_ == 'larr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'larr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_larr'):
              self.add_larr(obj_.value)
            elif hasattr(self, 'set_larr'):
              self.set_larr(obj_.value)
        elif nodeName_ == 'uarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uarr'):
              self.add_uarr(obj_.value)
            elif hasattr(self, 'set_uarr'):
              self.set_uarr(obj_.value)
        elif nodeName_ == 'rarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rarr'):
              self.add_rarr(obj_.value)
            elif hasattr(self, 'set_rarr'):
              self.set_rarr(obj_.value)
        elif nodeName_ == 'darr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'darr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_darr'):
              self.add_darr(obj_.value)
            elif hasattr(self, 'set_darr'):
              self.set_darr(obj_.value)
        elif nodeName_ == 'harr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'harr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_harr'):
              self.add_harr(obj_.value)
            elif hasattr(self, 'set_harr'):
              self.set_harr(obj_.value)
        elif nodeName_ == 'crarr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'crarr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_crarr'):
              self.add_crarr(obj_.value)
            elif hasattr(self, 'set_crarr'):
              self.set_crarr(obj_.value)
        elif nodeName_ == 'lArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lArr'):
              self.add_lArr(obj_.value)
            elif hasattr(self, 'set_lArr'):
              self.set_lArr(obj_.value)
        elif nodeName_ == 'uArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'uArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_uArr'):
              self.add_uArr(obj_.value)
            elif hasattr(self, 'set_uArr'):
              self.set_uArr(obj_.value)
        elif nodeName_ == 'rArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rArr'):
              self.add_rArr(obj_.value)
            elif hasattr(self, 'set_rArr'):
              self.set_rArr(obj_.value)
        elif nodeName_ == 'dArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dArr'):
              self.add_dArr(obj_.value)
            elif hasattr(self, 'set_dArr'):
              self.set_dArr(obj_.value)
        elif nodeName_ == 'hArr':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hArr', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hArr'):
              self.add_hArr(obj_.value)
            elif hasattr(self, 'set_hArr'):
              self.set_hArr(obj_.value)
        elif nodeName_ == 'forall':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'forall', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_forall'):
              self.add_forall(obj_.value)
            elif hasattr(self, 'set_forall'):
              self.set_forall(obj_.value)
        elif nodeName_ == 'part':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'part', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_part'):
              self.add_part(obj_.value)
            elif hasattr(self, 'set_part'):
              self.set_part(obj_.value)
        elif nodeName_ == 'exist':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'exist', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_exist'):
              self.add_exist(obj_.value)
            elif hasattr(self, 'set_exist'):
              self.set_exist(obj_.value)
        elif nodeName_ == 'empty':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'empty', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_empty'):
              self.add_empty(obj_.value)
            elif hasattr(self, 'set_empty'):
              self.set_empty(obj_.value)
        elif nodeName_ == 'nabla':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nabla', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nabla'):
              self.add_nabla(obj_.value)
            elif hasattr(self, 'set_nabla'):
              self.set_nabla(obj_.value)
        elif nodeName_ == 'isin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'isin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_isin'):
              self.add_isin(obj_.value)
            elif hasattr(self, 'set_isin'):
              self.set_isin(obj_.value)
        elif nodeName_ == 'notin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'notin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_notin'):
              self.add_notin(obj_.value)
            elif hasattr(self, 'set_notin'):
              self.set_notin(obj_.value)
        elif nodeName_ == 'ni':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ni', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ni'):
              self.add_ni(obj_.value)
            elif hasattr(self, 'set_ni'):
              self.set_ni(obj_.value)
        elif nodeName_ == 'prod':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prod', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prod'):
              self.add_prod(obj_.value)
            elif hasattr(self, 'set_prod'):
              self.set_prod(obj_.value)
        elif nodeName_ == 'sum':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sum', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sum'):
              self.add_sum(obj_.value)
            elif hasattr(self, 'set_sum'):
              self.set_sum(obj_.value)
        elif nodeName_ == 'minus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'minus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_minus'):
              self.add_minus(obj_.value)
            elif hasattr(self, 'set_minus'):
              self.set_minus(obj_.value)
        elif nodeName_ == 'lowast':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lowast', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lowast'):
              self.add_lowast(obj_.value)
            elif hasattr(self, 'set_lowast'):
              self.set_lowast(obj_.value)
        elif nodeName_ == 'radic':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'radic', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_radic'):
              self.add_radic(obj_.value)
            elif hasattr(self, 'set_radic'):
              self.set_radic(obj_.value)
        elif nodeName_ == 'prop':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'prop', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_prop'):
              self.add_prop(obj_.value)
            elif hasattr(self, 'set_prop'):
              self.set_prop(obj_.value)
        elif nodeName_ == 'infin':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'infin', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_infin'):
              self.add_infin(obj_.value)
            elif hasattr(self, 'set_infin'):
              self.set_infin(obj_.value)
        elif nodeName_ == 'ang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ang'):
              self.add_ang(obj_.value)
            elif hasattr(self, 'set_ang'):
              self.set_ang(obj_.value)
        elif nodeName_ == 'and':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'and', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_and'):
              self.add_and(obj_.value)
            elif hasattr(self, 'set_and'):
              self.set_and(obj_.value)
        elif nodeName_ == 'or':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'or', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_or'):
              self.add_or(obj_.value)
            elif hasattr(self, 'set_or'):
              self.set_or(obj_.value)
        elif nodeName_ == 'cap':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cap', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cap'):
              self.add_cap(obj_.value)
            elif hasattr(self, 'set_cap'):
              self.set_cap(obj_.value)
        elif nodeName_ == 'cup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cup'):
              self.add_cup(obj_.value)
            elif hasattr(self, 'set_cup'):
              self.set_cup(obj_.value)
        elif nodeName_ == 'int':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'int', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_int'):
              self.add_int(obj_.value)
            elif hasattr(self, 'set_int'):
              self.set_int(obj_.value)
        elif nodeName_ == 'there4':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'there4', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_there4'):
              self.add_there4(obj_.value)
            elif hasattr(self, 'set_there4'):
              self.set_there4(obj_.value)
        elif nodeName_ == 'sim':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sim', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sim'):
              self.add_sim(obj_.value)
            elif hasattr(self, 'set_sim'):
              self.set_sim(obj_.value)
        elif nodeName_ == 'cong':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'cong', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_cong'):
              self.add_cong(obj_.value)
            elif hasattr(self, 'set_cong'):
              self.set_cong(obj_.value)
        elif nodeName_ == 'asymp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'asymp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_asymp'):
              self.add_asymp(obj_.value)
            elif hasattr(self, 'set_asymp'):
              self.set_asymp(obj_.value)
        elif nodeName_ == 'ne':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ne', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ne'):
              self.add_ne(obj_.value)
            elif hasattr(self, 'set_ne'):
              self.set_ne(obj_.value)
        elif nodeName_ == 'equiv':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'equiv', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_equiv'):
              self.add_equiv(obj_.value)
            elif hasattr(self, 'set_equiv'):
              self.set_equiv(obj_.value)
        elif nodeName_ == 'le':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'le', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_le'):
              self.add_le(obj_.value)
            elif hasattr(self, 'set_le'):
              self.set_le(obj_.value)
        elif nodeName_ == 'ge':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ge', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ge'):
              self.add_ge(obj_.value)
            elif hasattr(self, 'set_ge'):
              self.set_ge(obj_.value)
        elif nodeName_ == 'sub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sub'):
              self.add_sub(obj_.value)
            elif hasattr(self, 'set_sub'):
              self.set_sub(obj_.value)
        elif nodeName_ == 'sup':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sup', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sup'):
              self.add_sup(obj_.value)
            elif hasattr(self, 'set_sup'):
              self.set_sup(obj_.value)
        elif nodeName_ == 'nsub':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'nsub', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_nsub'):
              self.add_nsub(obj_.value)
            elif hasattr(self, 'set_nsub'):
              self.set_nsub(obj_.value)
        elif nodeName_ == 'sube':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sube', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sube'):
              self.add_sube(obj_.value)
            elif hasattr(self, 'set_sube'):
              self.set_sube(obj_.value)
        elif nodeName_ == 'supe':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'supe', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_supe'):
              self.add_supe(obj_.value)
            elif hasattr(self, 'set_supe'):
              self.set_supe(obj_.value)
        elif nodeName_ == 'oplus':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oplus', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oplus'):
              self.add_oplus(obj_.value)
            elif hasattr(self, 'set_oplus'):
              self.set_oplus(obj_.value)
        elif nodeName_ == 'otimes':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'otimes', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_otimes'):
              self.add_otimes(obj_.value)
            elif hasattr(self, 'set_otimes'):
              self.set_otimes(obj_.value)
        elif nodeName_ == 'perp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'perp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_perp'):
              self.add_perp(obj_.value)
            elif hasattr(self, 'set_perp'):
              self.set_perp(obj_.value)
        elif nodeName_ == 'sdot':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sdot', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sdot'):
              self.add_sdot(obj_.value)
            elif hasattr(self, 'set_sdot'):
              self.set_sdot(obj_.value)
        elif nodeName_ == 'lceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lceil'):
              self.add_lceil(obj_.value)
            elif hasattr(self, 'set_lceil'):
              self.set_lceil(obj_.value)
        elif nodeName_ == 'rceil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rceil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rceil'):
              self.add_rceil(obj_.value)
            elif hasattr(self, 'set_rceil'):
              self.set_rceil(obj_.value)
        elif nodeName_ == 'lfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lfloor'):
              self.add_lfloor(obj_.value)
            elif hasattr(self, 'set_lfloor'):
              self.set_lfloor(obj_.value)
        elif nodeName_ == 'rfloor':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rfloor', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rfloor'):
              self.add_rfloor(obj_.value)
            elif hasattr(self, 'set_rfloor'):
              self.set_rfloor(obj_.value)
        elif nodeName_ == 'lang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lang'):
              self.add_lang(obj_.value)
            elif hasattr(self, 'set_lang'):
              self.set_lang(obj_.value)
        elif nodeName_ == 'rang':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rang', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rang'):
              self.add_rang(obj_.value)
            elif hasattr(self, 'set_rang'):
              self.set_rang(obj_.value)
        elif nodeName_ == 'loz':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'loz', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_loz'):
              self.add_loz(obj_.value)
            elif hasattr(self, 'set_loz'):
              self.set_loz(obj_.value)
        elif nodeName_ == 'spades':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'spades', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_spades'):
              self.add_spades(obj_.value)
            elif hasattr(self, 'set_spades'):
              self.set_spades(obj_.value)
        elif nodeName_ == 'clubs':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'clubs', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_clubs'):
              self.add_clubs(obj_.value)
            elif hasattr(self, 'set_clubs'):
              self.set_clubs(obj_.value)
        elif nodeName_ == 'hearts':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'hearts', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_hearts'):
              self.add_hearts(obj_.value)
            elif hasattr(self, 'set_hearts'):
              self.set_hearts(obj_.value)
        elif nodeName_ == 'diams':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'diams', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_diams'):
              self.add_diams(obj_.value)
            elif hasattr(self, 'set_diams'):
              self.set_diams(obj_.value)
        elif nodeName_ == 'OElig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'OElig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_OElig'):
              self.add_OElig(obj_.value)
            elif hasattr(self, 'set_OElig'):
              self.set_OElig(obj_.value)
        elif nodeName_ == 'oelig':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'oelig', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_oelig'):
              self.add_oelig(obj_.value)
            elif hasattr(self, 'set_oelig'):
              self.set_oelig(obj_.value)
        elif nodeName_ == 'Scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Scaron'):
              self.add_Scaron(obj_.value)
            elif hasattr(self, 'set_Scaron'):
              self.set_Scaron(obj_.value)
        elif nodeName_ == 'scaron':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'scaron', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_scaron'):
              self.add_scaron(obj_.value)
            elif hasattr(self, 'set_scaron'):
              self.set_scaron(obj_.value)
        elif nodeName_ == 'Yumlaut':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Yumlaut', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Yumlaut'):
              self.add_Yumlaut(obj_.value)
            elif hasattr(self, 'set_Yumlaut'):
              self.set_Yumlaut(obj_.value)
        elif nodeName_ == 'circ':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'circ', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_circ'):
              self.add_circ(obj_.value)
            elif hasattr(self, 'set_circ'):
              self.set_circ(obj_.value)
        elif nodeName_ == 'tilde':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tilde', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tilde'):
              self.add_tilde(obj_.value)
            elif hasattr(self, 'set_tilde'):
              self.set_tilde(obj_.value)
        elif nodeName_ == 'ensp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ensp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ensp'):
              self.add_ensp(obj_.value)
            elif hasattr(self, 'set_ensp'):
              self.set_ensp(obj_.value)
        elif nodeName_ == 'emsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'emsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_emsp'):
              self.add_emsp(obj_.value)
            elif hasattr(self, 'set_emsp'):
              self.set_emsp(obj_.value)
        elif nodeName_ == 'thinsp':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'thinsp', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_thinsp'):
              self.add_thinsp(obj_.value)
            elif hasattr(self, 'set_thinsp'):
              self.set_thinsp(obj_.value)
        elif nodeName_ == 'zwnj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwnj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwnj'):
              self.add_zwnj(obj_.value)
            elif hasattr(self, 'set_zwnj'):
              self.set_zwnj(obj_.value)
        elif nodeName_ == 'zwj':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'zwj', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_zwj'):
              self.add_zwj(obj_.value)
            elif hasattr(self, 'set_zwj'):
              self.set_zwj(obj_.value)
        elif nodeName_ == 'lrm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lrm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lrm'):
              self.add_lrm(obj_.value)
            elif hasattr(self, 'set_lrm'):
              self.set_lrm(obj_.value)
        elif nodeName_ == 'rlm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rlm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rlm'):
              self.add_rlm(obj_.value)
            elif hasattr(self, 'set_rlm'):
              self.set_rlm(obj_.value)
        elif nodeName_ == 'ndash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ndash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ndash'):
              self.add_ndash(obj_.value)
            elif hasattr(self, 'set_ndash'):
              self.set_ndash(obj_.value)
        elif nodeName_ == 'mdash':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'mdash', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_mdash'):
              self.add_mdash(obj_.value)
            elif hasattr(self, 'set_mdash'):
              self.set_mdash(obj_.value)
        elif nodeName_ == 'lsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsquo'):
              self.add_lsquo(obj_.value)
            elif hasattr(self, 'set_lsquo'):
              self.set_lsquo(obj_.value)
        elif nodeName_ == 'rsquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsquo'):
              self.add_rsquo(obj_.value)
            elif hasattr(self, 'set_rsquo'):
              self.set_rsquo(obj_.value)
        elif nodeName_ == 'sbquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'sbquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_sbquo'):
              self.add_sbquo(obj_.value)
            elif hasattr(self, 'set_sbquo'):
              self.set_sbquo(obj_.value)
        elif nodeName_ == 'ldquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ldquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ldquo'):
              self.add_ldquo(obj_.value)
            elif hasattr(self, 'set_ldquo'):
              self.set_ldquo(obj_.value)
        elif nodeName_ == 'rdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rdquo'):
              self.add_rdquo(obj_.value)
            elif hasattr(self, 'set_rdquo'):
              self.set_rdquo(obj_.value)
        elif nodeName_ == 'bdquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'bdquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_bdquo'):
              self.add_bdquo(obj_.value)
            elif hasattr(self, 'set_bdquo'):
              self.set_bdquo(obj_.value)
        elif nodeName_ == 'dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_dagger'):
              self.add_dagger(obj_.value)
            elif hasattr(self, 'set_dagger'):
              self.set_dagger(obj_.value)
        elif nodeName_ == 'Dagger':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'Dagger', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_Dagger'):
              self.add_Dagger(obj_.value)
            elif hasattr(self, 'set_Dagger'):
              self.set_Dagger(obj_.value)
        elif nodeName_ == 'permil':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'permil', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_permil'):
              self.add_permil(obj_.value)
            elif hasattr(self, 'set_permil'):
              self.set_permil(obj_.value)
        elif nodeName_ == 'lsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'lsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_lsaquo'):
              self.add_lsaquo(obj_.value)
            elif hasattr(self, 'set_lsaquo'):
              self.set_lsaquo(obj_.value)
        elif nodeName_ == 'rsaquo':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'rsaquo', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_rsaquo'):
              self.add_rsaquo(obj_.value)
            elif hasattr(self, 'set_rsaquo'):
              self.set_rsaquo(obj_.value)
        elif nodeName_ == 'euro':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'euro', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_euro'):
              self.add_euro(obj_.value)
            elif hasattr(self, 'set_euro'):
              self.set_euro(obj_.value)
        elif nodeName_ == 'tm':
            obj_ = docEmptyType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'tm', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_tm'):
              self.add_tm(obj_.value)
            elif hasattr(self, 'set_tm'):
              self.set_tm(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docTocItemType


class docTocListType(GeneratedsSuper):
    node_type = "doctoclist"

    subclass = None
    superclass = None
    def __init__(self, tocitem=None):
        self.original_tagname_ = None
        if tocitem is None:
            self.tocitem = []
        else:
            self.tocitem = tocitem
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docTocListType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docTocListType.subclass:
            return docTocListType.subclass(*args_, **kwargs_)
        else:
            return docTocListType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_tocitem(self): return self.tocitem
    def set_tocitem(self, tocitem): self.tocitem = tocitem
    def add_tocitem(self, value): self.tocitem.append(value)
    def insert_tocitem_at(self, index, value): self.tocitem.insert(index, value)
    def replace_tocitem_at(self, index, value): self.tocitem[index] = value
    def hasContent_(self):
        if (
            self.tocitem
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docTocListType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docTocListType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docTocListType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docTocListType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docTocListType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docTocListType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for tocitem_ in self.tocitem:
            tocitem_.export(outfile, level, namespace_, name_='tocitem', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'tocitem':
            obj_ = docTocItemType.factory()
            obj_.build(child_)
            self.tocitem.append(obj_)
            obj_.original_tagname_ = 'tocitem'
# end class docTocListType


class docLanguageType(GeneratedsSuper):
    node_type = "doclanguage"

    subclass = None
    superclass = None
    def __init__(self, langid=None, para=None):
        self.original_tagname_ = None
        self.langid = _cast(None, langid)
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docLanguageType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docLanguageType.subclass:
            return docLanguageType.subclass(*args_, **kwargs_)
        else:
            return docLanguageType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_langid(self): return self.langid
    def set_langid(self, langid): self.langid = langid
    def hasContent_(self):
        if (
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docLanguageType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docLanguageType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docLanguageType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docLanguageType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docLanguageType'):
        if self.langid is not None and 'langid' not in already_processed:
            already_processed.add('langid')
            outfile.write(' langid=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.langid), input_name='langid')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docLanguageType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('langid', node)
        if value is not None and 'langid' not in already_processed:
            already_processed.add('langid')
            self.langid = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docLanguageType


class docParamListType(GeneratedsSuper):
    node_type = "docparamlist"

    subclass = None
    superclass = None
    def __init__(self, kind=None, parameteritem=None):
        self.original_tagname_ = None
        self.kind = _cast(None, kind)
        if parameteritem is None:
            self.parameteritem = []
        else:
            self.parameteritem = parameteritem
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParamListType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParamListType.subclass:
            return docParamListType.subclass(*args_, **kwargs_)
        else:
            return docParamListType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_parameteritem(self): return self.parameteritem
    def set_parameteritem(self, parameteritem): self.parameteritem = parameteritem
    def add_parameteritem(self, value): self.parameteritem.append(value)
    def insert_parameteritem_at(self, index, value): self.parameteritem.insert(index, value)
    def replace_parameteritem_at(self, index, value): self.parameteritem[index] = value
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def validate_DoxParamListKind(self, value):
        # Validate type DoxParamListKind, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['param', 'retval', 'exception', 'templateparam']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxParamListKind' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.parameteritem
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParamListType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamListType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParamListType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParamListType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParamListType'):
        if self.kind is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docParamListType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for parameteritem_ in self.parameteritem:
            parameteritem_.export(outfile, level, namespace_, name_='parameteritem', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('kind', node)
        if value is not None and 'kind' not in already_processed:
            already_processed.add('kind')
            self.kind = value
            self.validate_DoxParamListKind(self.kind)    # validate type DoxParamListKind
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'parameteritem':
            obj_ = docParamListItem.factory()
            obj_.build(child_)
            self.parameteritem.append(obj_)
            obj_.original_tagname_ = 'parameteritem'
# end class docParamListType


class docParamListItem(GeneratedsSuper):
    node_type = "docparamlistitem"

    subclass = None
    superclass = None
    def __init__(self, parameternamelist=None, parameterdescription=None):
        self.original_tagname_ = None
        if parameternamelist is None:
            self.parameternamelist = []
        else:
            self.parameternamelist = parameternamelist
        self.parameterdescription = parameterdescription
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParamListItem)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParamListItem.subclass:
            return docParamListItem.subclass(*args_, **kwargs_)
        else:
            return docParamListItem(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_parameternamelist(self): return self.parameternamelist
    def set_parameternamelist(self, parameternamelist): self.parameternamelist = parameternamelist
    def add_parameternamelist(self, value): self.parameternamelist.append(value)
    def insert_parameternamelist_at(self, index, value): self.parameternamelist.insert(index, value)
    def replace_parameternamelist_at(self, index, value): self.parameternamelist[index] = value
    def get_parameterdescription(self): return self.parameterdescription
    def set_parameterdescription(self, parameterdescription): self.parameterdescription = parameterdescription
    def hasContent_(self):
        if (
            self.parameternamelist or
            self.parameterdescription is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParamListItem', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamListItem')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParamListItem')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParamListItem', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParamListItem'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docParamListItem', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for parameternamelist_ in self.parameternamelist:
            parameternamelist_.export(outfile, level, namespace_, name_='parameternamelist', pretty_print=pretty_print)
        if self.parameterdescription is not None:
            self.parameterdescription.export(outfile, level, namespace_, name_='parameterdescription', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'parameternamelist':
            obj_ = docParamNameList.factory()
            obj_.build(child_)
            self.parameternamelist.append(obj_)
            obj_.original_tagname_ = 'parameternamelist'
        elif nodeName_ == 'parameterdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.parameterdescription = obj_
            obj_.original_tagname_ = 'parameterdescription'
# end class docParamListItem


class docParamNameList(GeneratedsSuper):
    node_type = "docparamnamelist"

    subclass = None
    superclass = None
    def __init__(self, parametertype=None, parametername=None):
        self.original_tagname_ = None
        if parametertype is None:
            self.parametertype = []
        else:
            self.parametertype = parametertype
        if parametername is None:
            self.parametername = []
        else:
            self.parametername = parametername
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParamNameList)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParamNameList.subclass:
            return docParamNameList.subclass(*args_, **kwargs_)
        else:
            return docParamNameList(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_parametertype(self): return self.parametertype
    def set_parametertype(self, parametertype): self.parametertype = parametertype
    def add_parametertype(self, value): self.parametertype.append(value)
    def insert_parametertype_at(self, index, value): self.parametertype.insert(index, value)
    def replace_parametertype_at(self, index, value): self.parametertype[index] = value
    def get_parametername(self): return self.parametername
    def set_parametername(self, parametername): self.parametername = parametername
    def add_parametername(self, value): self.parametername.append(value)
    def insert_parametername_at(self, index, value): self.parametername.insert(index, value)
    def replace_parametername_at(self, index, value): self.parametername[index] = value
    def hasContent_(self):
        if (
            self.parametertype or
            self.parametername
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParamNameList', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamNameList')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParamNameList')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParamNameList', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParamNameList'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docParamNameList', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for parametertype_ in self.parametertype:
            parametertype_.export(outfile, level, namespace_, name_='parametertype', pretty_print=pretty_print)
        for parametername_ in self.parametername:
            parametername_.export(outfile, level, namespace_, name_='parametername', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'parametertype':
            obj_ = docParamType.factory()
            obj_.build(child_)
            self.parametertype.append(obj_)
            obj_.original_tagname_ = 'parametertype'
        elif nodeName_ == 'parametername':
            obj_ = docParamName.factory()
            obj_.build(child_)
            self.parametername.append(obj_)
            obj_.original_tagname_ = 'parametername'
# end class docParamNameList


class docParamType(GeneratedsSuper):
    node_type = "docparam"

    subclass = None
    superclass = None
    def __init__(self, ref=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.ref = ref
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParamType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParamType.subclass:
            return docParamType.subclass(*args_, **kwargs_)
        else:
            return docParamType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def hasContent_(self):
        if (
            self.ref is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParamType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParamType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParamType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParamType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docParamType', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ref is not None:
            self.ref.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ref':
            obj_ = refTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docParamType


class docParamName(GeneratedsSuper):
    node_type = "docparamname"

    subclass = None
    superclass = None
    def __init__(self, direction=None, ref=None, valueOf_=None, mixedclass_=None, content_=None):
        self.original_tagname_ = None
        self.direction = _cast(None, direction)
        self.ref = ref
        self.valueOf_ = valueOf_
        if mixedclass_ is None:
            self.mixedclass_ = MixedContainer
        else:
            self.mixedclass_ = mixedclass_
        if content_ is None:
            self.content_ = []
        else:
            self.content_ = content_
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParamName)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParamName.subclass:
            return docParamName.subclass(*args_, **kwargs_)
        else:
            return docParamName(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ref(self): return self.ref
    def set_ref(self, ref): self.ref = ref
    def get_direction(self): return self.direction
    def set_direction(self, direction): self.direction = direction
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_DoxParamDir(self, value):
        # Validate type DoxParamDir, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_:
            value = str(value)
            enumerations = ['in', 'out', 'inout']
            enumeration_respectee = False
            for enum in enumerations:
                if value == enum:
                    enumeration_respectee = True
                    break
            if not enumeration_respectee:
                warnings_.warn('Value "%(value)s" does not match xsd enumeration restriction on DoxParamDir' % {"value" : value.encode("utf-8")} )
    def hasContent_(self):
        if (
            self.ref is not None or
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParamName', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParamName')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParamName')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParamName', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParamName'):
        if self.direction is not None and 'direction' not in already_processed:
            already_processed.add('direction')
            outfile.write(' direction=%s' % (quote_attrib(self.direction), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docParamName', fromsubclass_=False, pretty_print=True):
        if not fromsubclass_:
            for item_ in self.content_:
                item_.export(outfile, level, item_.name, namespace_, pretty_print=pretty_print)
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ref is not None:
            self.ref.export(outfile, level, namespace_, name_='ref', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        if node.text is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', node.text)
            self.content_.append(obj_)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('direction', node)
        if value is not None and 'direction' not in already_processed:
            already_processed.add('direction')
            self.direction = value
            self.validate_DoxParamDir(self.direction)    # validate type DoxParamDir
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'ref':
            obj_ = refTextType.factory()
            obj_.build(child_)
            obj_ = self.mixedclass_(MixedContainer.CategoryComplex,
                MixedContainer.TypeNone, 'ref', obj_)
            self.content_.append(obj_)
            if hasattr(self, 'add_ref'):
              self.add_ref(obj_.value)
            elif hasattr(self, 'set_ref'):
              self.set_ref(obj_.value)
        if not fromsubclass_ and child_.tail is not None:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.tail)
            self.content_.append(obj_)
# end class docParamName


class docXRefSectType(GeneratedsSuper):
    node_type = "docxrefsect"

    subclass = None
    superclass = None
    def __init__(self, id=None, xreftitle=None, xrefdescription=None):
        self.original_tagname_ = None
        self.id = _cast(None, id)
        if xreftitle is None:
            self.xreftitle = []
        else:
            self.xreftitle = xreftitle
        self.xrefdescription = xrefdescription
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docXRefSectType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docXRefSectType.subclass:
            return docXRefSectType.subclass(*args_, **kwargs_)
        else:
            return docXRefSectType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_xreftitle(self): return self.xreftitle
    def set_xreftitle(self, xreftitle): self.xreftitle = xreftitle
    def add_xreftitle(self, value): self.xreftitle.append(value)
    def insert_xreftitle_at(self, index, value): self.xreftitle.insert(index, value)
    def replace_xreftitle_at(self, index, value): self.xreftitle[index] = value
    def get_xrefdescription(self): return self.xrefdescription
    def set_xrefdescription(self, xrefdescription): self.xrefdescription = xrefdescription
    def get_id(self): return self.id
    def set_id(self, id): self.id = id
    def hasContent_(self):
        if (
            self.xreftitle or
            self.xrefdescription is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docXRefSectType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docXRefSectType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docXRefSectType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docXRefSectType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docXRefSectType'):
        if self.id is not None and 'id' not in already_processed:
            already_processed.add('id')
            outfile.write(' id=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.id), input_name='id')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docXRefSectType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for xreftitle_ in self.xreftitle:
            showIndent(outfile, level, pretty_print)
            outfile.write('<xreftitle>%s</xreftitle>%s' % (self.gds_encode(self.gds_format_string(quote_xml(xreftitle_), input_name='xreftitle')), eol_))
        if self.xrefdescription is not None:
            self.xrefdescription.export(outfile, level, namespace_, name_='xrefdescription', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('id', node)
        if value is not None and 'id' not in already_processed:
            already_processed.add('id')
            self.id = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'xreftitle':
            xreftitle_ = child_.text
            xreftitle_ = self.gds_validate_string(xreftitle_, node, 'xreftitle')
            self.xreftitle.append(xreftitle_)
        elif nodeName_ == 'xrefdescription':
            obj_ = descriptionType.factory()
            obj_.build(child_)
            self.xrefdescription = obj_
            obj_.original_tagname_ = 'xrefdescription'
# end class docXRefSectType


class docCopyType(GeneratedsSuper):
    node_type = "doccopy"

    subclass = None
    superclass = None
    def __init__(self, link=None, para=None, sect1=None, internal=None):
        self.original_tagname_ = None
        self.link = _cast(None, link)
        if para is None:
            self.para = []
        else:
            self.para = para
        if sect1 is None:
            self.sect1 = []
        else:
            self.sect1 = sect1
        self.internal = internal
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docCopyType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docCopyType.subclass:
            return docCopyType.subclass(*args_, **kwargs_)
        else:
            return docCopyType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def get_sect1(self): return self.sect1
    def set_sect1(self, sect1): self.sect1 = sect1
    def add_sect1(self, value): self.sect1.append(value)
    def insert_sect1_at(self, index, value): self.sect1.insert(index, value)
    def replace_sect1_at(self, index, value): self.sect1[index] = value
    def get_internal(self): return self.internal
    def set_internal(self, internal): self.internal = internal
    def get_link(self): return self.link
    def set_link(self, link): self.link = link
    def hasContent_(self):
        if (
            self.para or
            self.sect1 or
            self.internal is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docCopyType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docCopyType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docCopyType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docCopyType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docCopyType'):
        if self.link is not None and 'link' not in already_processed:
            already_processed.add('link')
            outfile.write(' link=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.link), input_name='link')), ))
    def exportChildren(self, outfile, level, namespace_='', name_='docCopyType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
        for sect1_ in self.sect1:
            sect1_.export(outfile, level, namespace_, name_='sect1', pretty_print=pretty_print)
        if self.internal is not None:
            self.internal.export(outfile, level, namespace_, name_='internal', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('link', node)
        if value is not None and 'link' not in already_processed:
            already_processed.add('link')
            self.link = value
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
        elif nodeName_ == 'sect1':
            obj_ = docSect1Type.factory()
            obj_.build(child_)
            self.sect1.append(obj_)
            obj_.original_tagname_ = 'sect1'
        elif nodeName_ == 'internal':
            obj_ = docInternalType.factory()
            obj_.build(child_)
            self.internal = obj_
            obj_.original_tagname_ = 'internal'
# end class docCopyType


class docBlockQuoteType(GeneratedsSuper):
    node_type = "docblockquote"

    subclass = None
    superclass = None
    def __init__(self, para=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docBlockQuoteType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docBlockQuoteType.subclass:
            return docBlockQuoteType.subclass(*args_, **kwargs_)
        else:
            return docBlockQuoteType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def hasContent_(self):
        if (
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docBlockQuoteType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docBlockQuoteType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docBlockQuoteType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docBlockQuoteType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docBlockQuoteType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docBlockQuoteType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docBlockQuoteType


class docParBlockType(GeneratedsSuper):
    node_type = "docparblock"

    subclass = None
    superclass = None
    def __init__(self, para=None):
        self.original_tagname_ = None
        if para is None:
            self.para = []
        else:
            self.para = para
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docParBlockType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docParBlockType.subclass:
            return docParBlockType.subclass(*args_, **kwargs_)
        else:
            return docParBlockType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_para(self): return self.para
    def set_para(self, para): self.para = para
    def add_para(self, value): self.para.append(value)
    def insert_para_at(self, index, value): self.para.insert(index, value)
    def replace_para_at(self, index, value): self.para[index] = value
    def hasContent_(self):
        if (
            self.para
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docParBlockType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docParBlockType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docParBlockType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docParBlockType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docParBlockType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docParBlockType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for para_ in self.para:
            para_.export(outfile, level, namespace_, name_='para', pretty_print=pretty_print)
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        if nodeName_ == 'para':
            obj_ = docParaType.factory()
            obj_.build(child_)
            self.para.append(obj_)
            obj_.original_tagname_ = 'para'
# end class docParBlockType


class docEmptyType(GeneratedsSuper):
    node_type = "docempty"

    subclass = None
    superclass = None
    def __init__(self):
        self.original_tagname_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, docEmptyType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if docEmptyType.subclass:
            return docEmptyType.subclass(*args_, **kwargs_)
        else:
            return docEmptyType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def hasContent_(self):
        if (

        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespace_='', name_='docEmptyType', namespacedef_='', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('docEmptyType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None:
            name_ = self.original_tagname_
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self.exportAttributes(outfile, level, already_processed, namespace_, name_='docEmptyType')
        if self.hasContent_():
            outfile.write('>%s' % (eol_, ))
            self.exportChildren(outfile, level + 1, namespace_='', name_='docEmptyType', pretty_print=pretty_print)
            outfile.write('</%s%s>%s' % (namespace_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='docEmptyType'):
        pass
    def exportChildren(self, outfile, level, namespace_='', name_='docEmptyType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node):
        already_processed = set()
        self.buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self.buildChildren(child, node, nodeName_)
        return self
    def buildAttributes(self, node, attrs, already_processed):
        pass
    def buildChildren(self, child_, node, nodeName_, fromsubclass_=False):
        pass
# end class docEmptyType


GDSClassesMapping = {
    'doxygen': DoxygenType,
}


USAGE_TEXT = """
Usage: python <Parser>.py [ -s ] <in_xml_file>
"""


def usage():
    print(USAGE_TEXT)
    sys.exit(1)


def get_root_tag(node):
    tag = Tag_pattern_.match(node.tag).groups()[-1]
    rootClass = GDSClassesMapping.get(tag)
    if rootClass is None:
        rootClass = globals().get(tag)
    return tag, rootClass


def parse(inFileName, silence=True):
    parser = None
    doc = parsexml_(inFileName, parser)
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'DoxygenType'
        rootClass = DoxygenType
    rootObj = rootClass.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    if not silence:
        sys.stdout.write('<?xml version="1.0" ?>\n')
        rootObj.export(
            sys.stdout, 0, name_=rootTag,
            namespacedef_='',
            pretty_print=True)
    return rootObj


def parseEtree(inFileName, silence=True):
    parser = None
    doc = parsexml_(inFileName, parser)
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'DoxygenType'
        rootClass = DoxygenType
    rootObj = rootClass.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    mapping = {}
    rootElement = rootObj.to_etree(None, name_=rootTag, mapping_=mapping)
    reverse_mapping = rootObj.gds_reverse_node_mapping(mapping)
    if not silence:
        content = etree_.tostring(
            rootElement, pretty_print=True,
            xml_declaration=True, encoding="utf-8")
        sys.stdout.write(content)
        sys.stdout.write('\n')
    return rootObj, rootElement, mapping, reverse_mapping


def parseString(inString, silence=True):
    '''Parse a string, create the object tree, and export it.

    Arguments:
    - inString -- A string.  This XML fragment should not start
      with an XML declaration containing an encoding.
    - silence -- A boolean.  If False, export the object.
    Returns -- The root object in the tree.
    '''
    parser = None
    rootNode= parsexmlstring_(inString, parser)
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'DoxygenType'
        rootClass = DoxygenType
    rootObj = rootClass.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    if not silence:
        sys.stdout.write('<?xml version="1.0" ?>\n')
        rootObj.export(
            sys.stdout, 0, name_=rootTag,
            namespacedef_='')
    return rootObj


def parseLiteral(inFileName, silence=True):
    parser = None
    doc = parsexml_(inFileName, parser)
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'DoxygenType'
        rootClass = DoxygenType
    rootObj = rootClass.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    if not silence:
        sys.stdout.write('#from compound import *\n\n')
        sys.stdout.write('import compound as model_\n\n')
        sys.stdout.write('rootObj = model_.rootClass(\n')
        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
        sys.stdout.write(')\n')
    return rootObj


def main():
    args = sys.argv[1:]
    if len(args) == 1:
        parse(args[0])
    else:
        usage()


if __name__ == '__main__':
    #import pdb; pdb.set_trace()
    main()


__all__ = [
    "DoxygenType",
    "childnodeType",
    "codelineType",
    "compoundRefType",
    "compounddefType",
    "descriptionType",
    "docAnchorType",
    "docBlockQuoteType",
    "docCaptionType",
    "docCopyType",
    "docEmptyType",
    "docEntryType",
    "docFileType",
    "docFormulaType",
    "docHeadingType",
    "docImageType",
    "docIndexEntryType",
    "docInternalS1Type",
    "docInternalS2Type",
    "docInternalS3Type",
    "docInternalS4Type",
    "docInternalType",
    "docLanguageType",
    "docListItemType",
    "docListType",
    "docMarkupType",
    "docParBlockType",
    "docParaType",
    "docParamListItem",
    "docParamListType",
    "docParamName",
    "docParamNameList",
    "docParamType",
    "docRefTextType",
    "docRowType",
    "docSect1Type",
    "docSect2Type",
    "docSect3Type",
    "docSect4Type",
    "docSimpleSectType",
    "docTableType",
    "docTitleType",
    "docTocItemType",
    "docTocListType",
    "docURLLink",
    "docVarListEntryType",
    "docVariableListType",
    "docXRefSectType",
    "enumvalueType",
    "graphType",
    "highlightType",
    "incType",
    "linkType",
    "linkedTextType",
    "listingType",
    "listofallmembersType",
    "locationType",
    "memberRefType",
    "memberdefType",
    "nodeType",
    "paramType",
    "refTextType",
    "refType",
    "referenceType",
    "reimplementType",
    "sectiondefType",
    "templateparamlistType"
]