# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_mmut', [dirname(__file__)])
        except ImportError:
            import _mmut
            return _mmut
        if fp is not None:
            try:
                _mod = imp.load_module('_mmut', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _mmut = swig_import_helper()
    del swig_import_helper
else:
    import _mmut
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _mmut.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _mmut.SwigPyIterator_value(self)
    def incr(self, n=1): return _mmut.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _mmut.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _mmut.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _mmut.SwigPyIterator_equal(self, *args)
    def copy(self): return _mmut.SwigPyIterator_copy(self)
    def next(self): return _mmut.SwigPyIterator_next(self)
    def __next__(self): return _mmut.SwigPyIterator___next__(self)
    def previous(self): return _mmut.SwigPyIterator_previous(self)
    def advance(self, *args): return _mmut.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _mmut.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _mmut.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _mmut.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _mmut.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _mmut.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _mmut.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _mmut.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class UnsignedIntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnsignedIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UnsignedIntVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.UnsignedIntVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.UnsignedIntVector___nonzero__(self)
    def __bool__(self): return _mmut.UnsignedIntVector___bool__(self)
    def __len__(self): return _mmut.UnsignedIntVector___len__(self)
    def pop(self): return _mmut.UnsignedIntVector_pop(self)
    def __getslice__(self, *args): return _mmut.UnsignedIntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.UnsignedIntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.UnsignedIntVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.UnsignedIntVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.UnsignedIntVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.UnsignedIntVector___setitem__(self, *args)
    def append(self, *args): return _mmut.UnsignedIntVector_append(self, *args)
    def empty(self): return _mmut.UnsignedIntVector_empty(self)
    def size(self): return _mmut.UnsignedIntVector_size(self)
    def clear(self): return _mmut.UnsignedIntVector_clear(self)
    def swap(self, *args): return _mmut.UnsignedIntVector_swap(self, *args)
    def get_allocator(self): return _mmut.UnsignedIntVector_get_allocator(self)
    def begin(self): return _mmut.UnsignedIntVector_begin(self)
    def end(self): return _mmut.UnsignedIntVector_end(self)
    def rbegin(self): return _mmut.UnsignedIntVector_rbegin(self)
    def rend(self): return _mmut.UnsignedIntVector_rend(self)
    def pop_back(self): return _mmut.UnsignedIntVector_pop_back(self)
    def erase(self, *args): return _mmut.UnsignedIntVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_UnsignedIntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.UnsignedIntVector_push_back(self, *args)
    def front(self): return _mmut.UnsignedIntVector_front(self)
    def back(self): return _mmut.UnsignedIntVector_back(self)
    def assign(self, *args): return _mmut.UnsignedIntVector_assign(self, *args)
    def resize(self, *args): return _mmut.UnsignedIntVector_resize(self, *args)
    def insert(self, *args): return _mmut.UnsignedIntVector_insert(self, *args)
    def reserve(self, *args): return _mmut.UnsignedIntVector_reserve(self, *args)
    def capacity(self): return _mmut.UnsignedIntVector_capacity(self)
    __swig_destroy__ = _mmut.delete_UnsignedIntVector
    __del__ = lambda self : None;
UnsignedIntVector_swigregister = _mmut.UnsignedIntVector_swigregister
UnsignedIntVector_swigregister(UnsignedIntVector)

class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.IntVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.IntVector___nonzero__(self)
    def __bool__(self): return _mmut.IntVector___bool__(self)
    def __len__(self): return _mmut.IntVector___len__(self)
    def pop(self): return _mmut.IntVector_pop(self)
    def __getslice__(self, *args): return _mmut.IntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.IntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.IntVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.IntVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.IntVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.IntVector___setitem__(self, *args)
    def append(self, *args): return _mmut.IntVector_append(self, *args)
    def empty(self): return _mmut.IntVector_empty(self)
    def size(self): return _mmut.IntVector_size(self)
    def clear(self): return _mmut.IntVector_clear(self)
    def swap(self, *args): return _mmut.IntVector_swap(self, *args)
    def get_allocator(self): return _mmut.IntVector_get_allocator(self)
    def begin(self): return _mmut.IntVector_begin(self)
    def end(self): return _mmut.IntVector_end(self)
    def rbegin(self): return _mmut.IntVector_rbegin(self)
    def rend(self): return _mmut.IntVector_rend(self)
    def pop_back(self): return _mmut.IntVector_pop_back(self)
    def erase(self, *args): return _mmut.IntVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_IntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.IntVector_push_back(self, *args)
    def front(self): return _mmut.IntVector_front(self)
    def back(self): return _mmut.IntVector_back(self)
    def assign(self, *args): return _mmut.IntVector_assign(self, *args)
    def resize(self, *args): return _mmut.IntVector_resize(self, *args)
    def insert(self, *args): return _mmut.IntVector_insert(self, *args)
    def reserve(self, *args): return _mmut.IntVector_reserve(self, *args)
    def capacity(self): return _mmut.IntVector_capacity(self)
    __swig_destroy__ = _mmut.delete_IntVector
    __del__ = lambda self : None;
IntVector_swigregister = _mmut.IntVector_swigregister
IntVector_swigregister(IntVector)

class IntIntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntIntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntIntVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.IntIntVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.IntIntVector___nonzero__(self)
    def __bool__(self): return _mmut.IntIntVector___bool__(self)
    def __len__(self): return _mmut.IntIntVector___len__(self)
    def pop(self): return _mmut.IntIntVector_pop(self)
    def __getslice__(self, *args): return _mmut.IntIntVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.IntIntVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.IntIntVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.IntIntVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.IntIntVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.IntIntVector___setitem__(self, *args)
    def append(self, *args): return _mmut.IntIntVector_append(self, *args)
    def empty(self): return _mmut.IntIntVector_empty(self)
    def size(self): return _mmut.IntIntVector_size(self)
    def clear(self): return _mmut.IntIntVector_clear(self)
    def swap(self, *args): return _mmut.IntIntVector_swap(self, *args)
    def get_allocator(self): return _mmut.IntIntVector_get_allocator(self)
    def begin(self): return _mmut.IntIntVector_begin(self)
    def end(self): return _mmut.IntIntVector_end(self)
    def rbegin(self): return _mmut.IntIntVector_rbegin(self)
    def rend(self): return _mmut.IntIntVector_rend(self)
    def pop_back(self): return _mmut.IntIntVector_pop_back(self)
    def erase(self, *args): return _mmut.IntIntVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_IntIntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.IntIntVector_push_back(self, *args)
    def front(self): return _mmut.IntIntVector_front(self)
    def back(self): return _mmut.IntIntVector_back(self)
    def assign(self, *args): return _mmut.IntIntVector_assign(self, *args)
    def resize(self, *args): return _mmut.IntIntVector_resize(self, *args)
    def insert(self, *args): return _mmut.IntIntVector_insert(self, *args)
    def reserve(self, *args): return _mmut.IntIntVector_reserve(self, *args)
    def capacity(self): return _mmut.IntIntVector_capacity(self)
    __swig_destroy__ = _mmut.delete_IntIntVector
    __del__ = lambda self : None;
IntIntVector_swigregister = _mmut.IntIntVector_swigregister
IntIntVector_swigregister(IntIntVector)

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.DoubleVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.DoubleVector___nonzero__(self)
    def __bool__(self): return _mmut.DoubleVector___bool__(self)
    def __len__(self): return _mmut.DoubleVector___len__(self)
    def pop(self): return _mmut.DoubleVector_pop(self)
    def __getslice__(self, *args): return _mmut.DoubleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.DoubleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.DoubleVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.DoubleVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.DoubleVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.DoubleVector___setitem__(self, *args)
    def append(self, *args): return _mmut.DoubleVector_append(self, *args)
    def empty(self): return _mmut.DoubleVector_empty(self)
    def size(self): return _mmut.DoubleVector_size(self)
    def clear(self): return _mmut.DoubleVector_clear(self)
    def swap(self, *args): return _mmut.DoubleVector_swap(self, *args)
    def get_allocator(self): return _mmut.DoubleVector_get_allocator(self)
    def begin(self): return _mmut.DoubleVector_begin(self)
    def end(self): return _mmut.DoubleVector_end(self)
    def rbegin(self): return _mmut.DoubleVector_rbegin(self)
    def rend(self): return _mmut.DoubleVector_rend(self)
    def pop_back(self): return _mmut.DoubleVector_pop_back(self)
    def erase(self, *args): return _mmut.DoubleVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.DoubleVector_push_back(self, *args)
    def front(self): return _mmut.DoubleVector_front(self)
    def back(self): return _mmut.DoubleVector_back(self)
    def assign(self, *args): return _mmut.DoubleVector_assign(self, *args)
    def resize(self, *args): return _mmut.DoubleVector_resize(self, *args)
    def insert(self, *args): return _mmut.DoubleVector_insert(self, *args)
    def reserve(self, *args): return _mmut.DoubleVector_reserve(self, *args)
    def capacity(self): return _mmut.DoubleVector_capacity(self)
    __swig_destroy__ = _mmut.delete_DoubleVector
    __del__ = lambda self : None;
DoubleVector_swigregister = _mmut.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class DoubleDoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.DoubleDoubleVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.DoubleDoubleVector___nonzero__(self)
    def __bool__(self): return _mmut.DoubleDoubleVector___bool__(self)
    def __len__(self): return _mmut.DoubleDoubleVector___len__(self)
    def pop(self): return _mmut.DoubleDoubleVector_pop(self)
    def __getslice__(self, *args): return _mmut.DoubleDoubleVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.DoubleDoubleVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.DoubleDoubleVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.DoubleDoubleVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.DoubleDoubleVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.DoubleDoubleVector___setitem__(self, *args)
    def append(self, *args): return _mmut.DoubleDoubleVector_append(self, *args)
    def empty(self): return _mmut.DoubleDoubleVector_empty(self)
    def size(self): return _mmut.DoubleDoubleVector_size(self)
    def clear(self): return _mmut.DoubleDoubleVector_clear(self)
    def swap(self, *args): return _mmut.DoubleDoubleVector_swap(self, *args)
    def get_allocator(self): return _mmut.DoubleDoubleVector_get_allocator(self)
    def begin(self): return _mmut.DoubleDoubleVector_begin(self)
    def end(self): return _mmut.DoubleDoubleVector_end(self)
    def rbegin(self): return _mmut.DoubleDoubleVector_rbegin(self)
    def rend(self): return _mmut.DoubleDoubleVector_rend(self)
    def pop_back(self): return _mmut.DoubleDoubleVector_pop_back(self)
    def erase(self, *args): return _mmut.DoubleDoubleVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_DoubleDoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.DoubleDoubleVector_push_back(self, *args)
    def front(self): return _mmut.DoubleDoubleVector_front(self)
    def back(self): return _mmut.DoubleDoubleVector_back(self)
    def assign(self, *args): return _mmut.DoubleDoubleVector_assign(self, *args)
    def resize(self, *args): return _mmut.DoubleDoubleVector_resize(self, *args)
    def insert(self, *args): return _mmut.DoubleDoubleVector_insert(self, *args)
    def reserve(self, *args): return _mmut.DoubleDoubleVector_reserve(self, *args)
    def capacity(self): return _mmut.DoubleDoubleVector_capacity(self)
    __swig_destroy__ = _mmut.delete_DoubleDoubleVector
    __del__ = lambda self : None;
DoubleDoubleVector_swigregister = _mmut.DoubleDoubleVector_swigregister
DoubleDoubleVector_swigregister(DoubleDoubleVector)

class MatrixVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.MatrixVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.MatrixVector___nonzero__(self)
    def __bool__(self): return _mmut.MatrixVector___bool__(self)
    def __len__(self): return _mmut.MatrixVector___len__(self)
    def pop(self): return _mmut.MatrixVector_pop(self)
    def __getslice__(self, *args): return _mmut.MatrixVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.MatrixVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.MatrixVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.MatrixVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.MatrixVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.MatrixVector___setitem__(self, *args)
    def append(self, *args): return _mmut.MatrixVector_append(self, *args)
    def empty(self): return _mmut.MatrixVector_empty(self)
    def size(self): return _mmut.MatrixVector_size(self)
    def clear(self): return _mmut.MatrixVector_clear(self)
    def swap(self, *args): return _mmut.MatrixVector_swap(self, *args)
    def get_allocator(self): return _mmut.MatrixVector_get_allocator(self)
    def begin(self): return _mmut.MatrixVector_begin(self)
    def end(self): return _mmut.MatrixVector_end(self)
    def rbegin(self): return _mmut.MatrixVector_rbegin(self)
    def rend(self): return _mmut.MatrixVector_rend(self)
    def pop_back(self): return _mmut.MatrixVector_pop_back(self)
    def erase(self, *args): return _mmut.MatrixVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_MatrixVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.MatrixVector_push_back(self, *args)
    def front(self): return _mmut.MatrixVector_front(self)
    def back(self): return _mmut.MatrixVector_back(self)
    def assign(self, *args): return _mmut.MatrixVector_assign(self, *args)
    def resize(self, *args): return _mmut.MatrixVector_resize(self, *args)
    def insert(self, *args): return _mmut.MatrixVector_insert(self, *args)
    def reserve(self, *args): return _mmut.MatrixVector_reserve(self, *args)
    def capacity(self): return _mmut.MatrixVector_capacity(self)
    __swig_destroy__ = _mmut.delete_MatrixVector
    __del__ = lambda self : None;
MatrixVector_swigregister = _mmut.MatrixVector_swigregister
MatrixVector_swigregister(MatrixVector)

class MatrixMatrixVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixMatrixVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixMatrixVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.MatrixMatrixVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.MatrixMatrixVector___nonzero__(self)
    def __bool__(self): return _mmut.MatrixMatrixVector___bool__(self)
    def __len__(self): return _mmut.MatrixMatrixVector___len__(self)
    def pop(self): return _mmut.MatrixMatrixVector_pop(self)
    def __getslice__(self, *args): return _mmut.MatrixMatrixVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.MatrixMatrixVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.MatrixMatrixVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.MatrixMatrixVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.MatrixMatrixVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.MatrixMatrixVector___setitem__(self, *args)
    def append(self, *args): return _mmut.MatrixMatrixVector_append(self, *args)
    def empty(self): return _mmut.MatrixMatrixVector_empty(self)
    def size(self): return _mmut.MatrixMatrixVector_size(self)
    def clear(self): return _mmut.MatrixMatrixVector_clear(self)
    def swap(self, *args): return _mmut.MatrixMatrixVector_swap(self, *args)
    def get_allocator(self): return _mmut.MatrixMatrixVector_get_allocator(self)
    def begin(self): return _mmut.MatrixMatrixVector_begin(self)
    def end(self): return _mmut.MatrixMatrixVector_end(self)
    def rbegin(self): return _mmut.MatrixMatrixVector_rbegin(self)
    def rend(self): return _mmut.MatrixMatrixVector_rend(self)
    def pop_back(self): return _mmut.MatrixMatrixVector_pop_back(self)
    def erase(self, *args): return _mmut.MatrixMatrixVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_MatrixMatrixVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.MatrixMatrixVector_push_back(self, *args)
    def front(self): return _mmut.MatrixMatrixVector_front(self)
    def back(self): return _mmut.MatrixMatrixVector_back(self)
    def assign(self, *args): return _mmut.MatrixMatrixVector_assign(self, *args)
    def resize(self, *args): return _mmut.MatrixMatrixVector_resize(self, *args)
    def insert(self, *args): return _mmut.MatrixMatrixVector_insert(self, *args)
    def reserve(self, *args): return _mmut.MatrixMatrixVector_reserve(self, *args)
    def capacity(self): return _mmut.MatrixMatrixVector_capacity(self)
    __swig_destroy__ = _mmut.delete_MatrixMatrixVector
    __del__ = lambda self : None;
MatrixMatrixVector_swigregister = _mmut.MatrixMatrixVector_swigregister
MatrixMatrixVector_swigregister(MatrixMatrixVector)

kdelta = _mmut.kdelta
class matrixRow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrixRow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrixRow, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mat"] = _mmut.matrixRow_mat_set
    __swig_getmethods__["mat"] = _mmut.matrixRow_mat_get
    if _newclass:mat = _swig_property(_mmut.matrixRow_mat_get, _mmut.matrixRow_mat_set)
    __swig_setmethods__["row"] = _mmut.matrixRow_row_set
    __swig_getmethods__["row"] = _mmut.matrixRow_row_get
    if _newclass:row = _swig_property(_mmut.matrixRow_row_get, _mmut.matrixRow_row_set)
    def __getitem__(self, *args): return _mmut.matrixRow___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.matrixRow___setitem__(self, *args)
    def __init__(self): 
        this = _mmut.new_matrixRow()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_matrixRow
    __del__ = lambda self : None;
matrixRow_swigregister = _mmut.matrixRow_swigregister
matrixRow_swigregister(matrixRow)

class CartesianVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CartesianVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CartesianVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.CartesianVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.CartesianVector___nonzero__(self)
    def __bool__(self): return _mmut.CartesianVector___bool__(self)
    def __len__(self): return _mmut.CartesianVector___len__(self)
    def pop(self): return _mmut.CartesianVector_pop(self)
    def __getslice__(self, *args): return _mmut.CartesianVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.CartesianVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.CartesianVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.CartesianVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.CartesianVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.CartesianVector___setitem__(self, *args)
    def append(self, *args): return _mmut.CartesianVector_append(self, *args)
    def empty(self): return _mmut.CartesianVector_empty(self)
    def size(self): return _mmut.CartesianVector_size(self)
    def clear(self): return _mmut.CartesianVector_clear(self)
    def swap(self, *args): return _mmut.CartesianVector_swap(self, *args)
    def get_allocator(self): return _mmut.CartesianVector_get_allocator(self)
    def begin(self): return _mmut.CartesianVector_begin(self)
    def end(self): return _mmut.CartesianVector_end(self)
    def rbegin(self): return _mmut.CartesianVector_rbegin(self)
    def rend(self): return _mmut.CartesianVector_rend(self)
    def pop_back(self): return _mmut.CartesianVector_pop_back(self)
    def erase(self, *args): return _mmut.CartesianVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_CartesianVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.CartesianVector_push_back(self, *args)
    def front(self): return _mmut.CartesianVector_front(self)
    def back(self): return _mmut.CartesianVector_back(self)
    def assign(self, *args): return _mmut.CartesianVector_assign(self, *args)
    def resize(self, *args): return _mmut.CartesianVector_resize(self, *args)
    def insert(self, *args): return _mmut.CartesianVector_insert(self, *args)
    def reserve(self, *args): return _mmut.CartesianVector_reserve(self, *args)
    def capacity(self): return _mmut.CartesianVector_capacity(self)
    __swig_destroy__ = _mmut.delete_CartesianVector
    __del__ = lambda self : None;
CartesianVector_swigregister = _mmut.CartesianVector_swigregister
CartesianVector_swigregister(CartesianVector)

class CartesianCartesianVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CartesianCartesianVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CartesianCartesianVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.CartesianCartesianVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.CartesianCartesianVector___nonzero__(self)
    def __bool__(self): return _mmut.CartesianCartesianVector___bool__(self)
    def __len__(self): return _mmut.CartesianCartesianVector___len__(self)
    def pop(self): return _mmut.CartesianCartesianVector_pop(self)
    def __getslice__(self, *args): return _mmut.CartesianCartesianVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.CartesianCartesianVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.CartesianCartesianVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.CartesianCartesianVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.CartesianCartesianVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.CartesianCartesianVector___setitem__(self, *args)
    def append(self, *args): return _mmut.CartesianCartesianVector_append(self, *args)
    def empty(self): return _mmut.CartesianCartesianVector_empty(self)
    def size(self): return _mmut.CartesianCartesianVector_size(self)
    def clear(self): return _mmut.CartesianCartesianVector_clear(self)
    def swap(self, *args): return _mmut.CartesianCartesianVector_swap(self, *args)
    def get_allocator(self): return _mmut.CartesianCartesianVector_get_allocator(self)
    def begin(self): return _mmut.CartesianCartesianVector_begin(self)
    def end(self): return _mmut.CartesianCartesianVector_end(self)
    def rbegin(self): return _mmut.CartesianCartesianVector_rbegin(self)
    def rend(self): return _mmut.CartesianCartesianVector_rend(self)
    def pop_back(self): return _mmut.CartesianCartesianVector_pop_back(self)
    def erase(self, *args): return _mmut.CartesianCartesianVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_CartesianCartesianVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.CartesianCartesianVector_push_back(self, *args)
    def front(self): return _mmut.CartesianCartesianVector_front(self)
    def back(self): return _mmut.CartesianCartesianVector_back(self)
    def assign(self, *args): return _mmut.CartesianCartesianVector_assign(self, *args)
    def resize(self, *args): return _mmut.CartesianCartesianVector_resize(self, *args)
    def insert(self, *args): return _mmut.CartesianCartesianVector_insert(self, *args)
    def reserve(self, *args): return _mmut.CartesianCartesianVector_reserve(self, *args)
    def capacity(self): return _mmut.CartesianCartesianVector_capacity(self)
    __swig_destroy__ = _mmut.delete_CartesianCartesianVector
    __del__ = lambda self : None;
CartesianCartesianVector_swigregister = _mmut.CartesianCartesianVector_swigregister
CartesianCartesianVector_swigregister(CartesianCartesianVector)

class Cartesian(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cartesian, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cartesian, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Cartesian(*args)
        try: self.this.append(this)
        except: self.this = this
    def getxyza(self): return _mmut.Cartesian_getxyza(self)
    def setxyza(self, *args): return _mmut.Cartesian_setxyza(self, *args)
    def getxyza_vec(self): return _mmut.Cartesian_getxyza_vec(self)
    def setxyza_vec(self, *args): return _mmut.Cartesian_setxyza_vec(self, *args)
    def get_x(self): return _mmut.Cartesian_get_x(self)
    def get_y(self): return _mmut.Cartesian_get_y(self)
    def get_z(self): return _mmut.Cartesian_get_z(self)
    def get_a(self): return _mmut.Cartesian_get_a(self)
    def set_x(self, *args): return _mmut.Cartesian_set_x(self, *args)
    def set_y(self, *args): return _mmut.Cartesian_set_y(self, *args)
    def set_z(self, *args): return _mmut.Cartesian_set_z(self, *args)
    def set_a(self, *args): return _mmut.Cartesian_set_a(self, *args)
    def set_xyz(self, *args): return _mmut.Cartesian_set_xyz(self, *args)
    def set_xyza(self, *args): return _mmut.Cartesian_set_xyza(self, *args)
    def setMultiplyAndAdd(self, *args): return _mmut.Cartesian_setMultiplyAndAdd(self, *args)
    __swig_getmethods__["CrossProduct"] = lambda x: _mmut.Cartesian_CrossProduct
    if _newclass:CrossProduct = staticmethod(_mmut.Cartesian_CrossProduct)
    __swig_getmethods__["DotProduct"] = lambda x: _mmut.Cartesian_DotProduct
    if _newclass:DotProduct = staticmethod(_mmut.Cartesian_DotProduct)
    __swig_getmethods__["MidPoint"] = lambda x: _mmut.Cartesian_MidPoint
    if _newclass:MidPoint = staticmethod(_mmut.Cartesian_MidPoint)
    __swig_getmethods__["RMSDistance"] = lambda x: _mmut.Cartesian_RMSDistance
    if _newclass:RMSDistance = staticmethod(_mmut.Cartesian_RMSDistance)
    __swig_getmethods__["PrincipalComponentAnalysis"] = lambda x: _mmut.Cartesian_PrincipalComponentAnalysis
    if _newclass:PrincipalComponentAnalysis = staticmethod(_mmut.Cartesian_PrincipalComponentAnalysis)
    def normalize(self, radius=1.0): return _mmut.Cartesian_normalize(self, radius)
    __swig_getmethods__["CheckDistanceRangeMin"] = lambda x: _mmut.Cartesian_CheckDistanceRangeMin
    if _newclass:CheckDistanceRangeMin = staticmethod(_mmut.Cartesian_CheckDistanceRangeMin)
    __swig_getmethods__["CheckDistanceRange"] = lambda x: _mmut.Cartesian_CheckDistanceRange
    if _newclass:CheckDistanceRange = staticmethod(_mmut.Cartesian_CheckDistanceRange)
    def __add__(self, *args): return _mmut.Cartesian___add__(self, *args)
    def __sub__(self, *args): return _mmut.Cartesian___sub__(self, *args)
    def __neg__(self): return _mmut.Cartesian___neg__(self)
    def __iadd__(self, *args): return _mmut.Cartesian___iadd__(self, *args)
    def __isub__(self, *args): return _mmut.Cartesian___isub__(self, *args)
    def __imul__(self, *args): return _mmut.Cartesian___imul__(self, *args)
    def __idiv__(self, *args): return _mmut.Cartesian___idiv__(self, *args)
    def length(self): return _mmut.Cartesian_length(self)
    def to_dp(self): return _mmut.Cartesian_to_dp(self)
    def Scale(self, *args): return _mmut.Cartesian_Scale(self, *args)
    def Print(self): return _mmut.Cartesian_Print(self)
    def __div__(self, *args): return _mmut.Cartesian___div__(self, *args)
    def __mul__(self, *args): return _mmut.Cartesian___mul__(self, *args)
    __swig_destroy__ = _mmut.delete_Cartesian
    __del__ = lambda self : None;
Cartesian_swigregister = _mmut.Cartesian_swigregister
Cartesian_swigregister(Cartesian)

def Cartesian_CrossProduct(*args):
  return _mmut.Cartesian_CrossProduct(*args)
Cartesian_CrossProduct = _mmut.Cartesian_CrossProduct

def Cartesian_DotProduct(*args):
  return _mmut.Cartesian_DotProduct(*args)
Cartesian_DotProduct = _mmut.Cartesian_DotProduct

def Cartesian_MidPoint(*args):
  return _mmut.Cartesian_MidPoint(*args)
Cartesian_MidPoint = _mmut.Cartesian_MidPoint

def Cartesian_RMSDistance(*args):
  return _mmut.Cartesian_RMSDistance(*args)
Cartesian_RMSDistance = _mmut.Cartesian_RMSDistance

def Cartesian_PrincipalComponentAnalysis(*args):
  return _mmut.Cartesian_PrincipalComponentAnalysis(*args)
Cartesian_PrincipalComponentAnalysis = _mmut.Cartesian_PrincipalComponentAnalysis

def Cartesian_CheckDistanceRangeMin(*args):
  return _mmut.Cartesian_CheckDistanceRangeMin(*args)
Cartesian_CheckDistanceRangeMin = _mmut.Cartesian_CheckDistanceRangeMin

def Cartesian_CheckDistanceRange(*args):
  return _mmut.Cartesian_CheckDistanceRange(*args)
Cartesian_CheckDistanceRange = _mmut.Cartesian_CheckDistanceRange


def Angle(*args):
  return _mmut.Angle(*args)
Angle = _mmut.Angle
class matrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, matrix, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _mmut.delete_matrix
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _mmut.new_matrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def to_dp(self): return _mmut.matrix_to_dp(self)
    def Zero(self): return _mmut.matrix_Zero(self)
    def get_rows(self): return _mmut.matrix_get_rows(self)
    def get_columns(self): return _mmut.matrix_get_columns(self)
    def Trace(self): return _mmut.matrix_Trace(self)
    def Transpose(self): return _mmut.matrix_Transpose(self)
    def fun(self, *args): return _mmut.matrix_fun(self, *args)
    def __add__(self, *args): return _mmut.matrix___add__(self, *args)
    def __sub__(self, *args): return _mmut.matrix___sub__(self, *args)
    def __eq__(self, *args): return _mmut.matrix___eq__(self, *args)
    def __ne__(self, *args): return _mmut.matrix___ne__(self, *args)
    def __iadd__(self, *args): return _mmut.matrix___iadd__(self, *args)
    def __isub__(self, *args): return _mmut.matrix___isub__(self, *args)
    def __imul__(self, *args): return _mmut.matrix___imul__(self, *args)
    def __idiv__(self, *args): return _mmut.matrix___idiv__(self, *args)
    def __neg__(self): return _mmut.matrix___neg__(self)
    __swig_getmethods__["DirSum"] = lambda x: _mmut.matrix_DirSum
    if _newclass:DirSum = staticmethod(_mmut.matrix_DirSum)
    def Eigen(self): return _mmut.matrix_Eigen(self)
    __swig_getmethods__["SortEigenvalues"] = lambda x: _mmut.matrix_SortEigenvalues
    if _newclass:SortEigenvalues = staticmethod(_mmut.matrix_SortEigenvalues)
    __swig_getmethods__["MinorMatrix"] = lambda x: _mmut.matrix_MinorMatrix
    if _newclass:MinorMatrix = staticmethod(_mmut.matrix_MinorMatrix)
    __swig_getmethods__["Minor"] = lambda x: _mmut.matrix_Minor
    if _newclass:Minor = staticmethod(_mmut.matrix_Minor)
    __swig_getmethods__["TriangularSolveForward"] = lambda x: _mmut.matrix_TriangularSolveForward
    if _newclass:TriangularSolveForward = staticmethod(_mmut.matrix_TriangularSolveForward)
    __swig_getmethods__["TriangularSolveBack"] = lambda x: _mmut.matrix_TriangularSolveBack
    if _newclass:TriangularSolveBack = staticmethod(_mmut.matrix_TriangularSolveBack)
    __swig_getmethods__["SolveLinearEquations"] = lambda x: _mmut.matrix_SolveLinearEquations
    if _newclass:SolveLinearEquations = staticmethod(_mmut.matrix_SolveLinearEquations)
    def SVD(self): return _mmut.matrix_SVD(self)
    def Bidiagonalize(self): return _mmut.matrix_Bidiagonalize(self)
    def LUDecomposition(self): return _mmut.matrix_LUDecomposition(self)
    def FrobeniusNorm(self): return _mmut.matrix_FrobeniusNorm(self)
    def Determinant(self): return _mmut.matrix_Determinant(self)
    def Inverse(self): return _mmut.matrix_Inverse(self)
    def BlockMatrix(self, *args): return _mmut.matrix_BlockMatrix(self, *args)
    def SwitchRows(self, *args): return _mmut.matrix_SwitchRows(self, *args)
    def __call__(self, *args): return _mmut.matrix___call__(self, *args)
    def Print(self): return _mmut.matrix_Print(self)
    def matrixVector(self): return _mmut.matrix_matrixVector(self)
    def Cholesky(self): return _mmut.matrix_Cholesky(self)
    def GaussianElimination(self, unitDiag=False): return _mmut.matrix_GaussianElimination(self, unitDiag)
    def GaussJordanElimination(self): return _mmut.matrix_GaussJordanElimination(self)
    def GetRotationAxis(self): return _mmut.matrix_GetRotationAxis(self)
    def QRDecomposition(self): return _mmut.matrix_QRDecomposition(self)
    def Hessenberg(self): return _mmut.matrix_Hessenberg(self)
    def Orthonormalize(self): return _mmut.matrix_Orthonormalize(self)
    def GetColumn(self, *args): return _mmut.matrix_GetColumn(self, *args)
    def GetRow(self, *args): return _mmut.matrix_GetRow(self, *args)
    def SetColumn(self, *args): return _mmut.matrix_SetColumn(self, *args)
    def SetRow(self, *args): return _mmut.matrix_SetRow(self, *args)
    def isNull(self): return _mmut.matrix_isNull(self)
    def MultiplyAndSetRight(self, *args): return _mmut.matrix_MultiplyAndSetRight(self, *args)
    def MultiplyAndSetLeft(self, *args): return _mmut.matrix_MultiplyAndSetLeft(self, *args)
    def GetEvecsAndEvalsFromEvals(self, *args): return _mmut.matrix_GetEvecsAndEvalsFromEvals(self, *args)
    def GetAsDoubleVectors(self): return _mmut.matrix_GetAsDoubleVectors(self)
    def __getitem__(self, *args): return _mmut.matrix___getitem__(self, *args)
    def __mul__(self, *args): return _mmut.matrix___mul__(self, *args)
    def __div__(self, *args): return _mmut.matrix___div__(self, *args)
matrix_swigregister = _mmut.matrix_swigregister
matrix_swigregister(matrix)

def pow(*args):
  return _mmut.pow(*args)
pow = _mmut.pow

def matrix_DirSum(*args):
  return _mmut.matrix_DirSum(*args)
matrix_DirSum = _mmut.matrix_DirSum

def matrix_SortEigenvalues(*args):
  return _mmut.matrix_SortEigenvalues(*args)
matrix_SortEigenvalues = _mmut.matrix_SortEigenvalues

def matrix_MinorMatrix(*args):
  return _mmut.matrix_MinorMatrix(*args)
matrix_MinorMatrix = _mmut.matrix_MinorMatrix

def matrix_Minor(*args):
  return _mmut.matrix_Minor(*args)
matrix_Minor = _mmut.matrix_Minor

def matrix_TriangularSolveForward(*args):
  return _mmut.matrix_TriangularSolveForward(*args)
matrix_TriangularSolveForward = _mmut.matrix_TriangularSolveForward

def matrix_TriangularSolveBack(*args):
  return _mmut.matrix_TriangularSolveBack(*args)
matrix_TriangularSolveBack = _mmut.matrix_TriangularSolveBack

def matrix_SolveLinearEquations(*args):
  return _mmut.matrix_SolveLinearEquations(*args)
matrix_SolveLinearEquations = _mmut.matrix_SolveLinearEquations

class TreeVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TreeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TreeVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.TreeVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.TreeVector___nonzero__(self)
    def __bool__(self): return _mmut.TreeVector___bool__(self)
    def __len__(self): return _mmut.TreeVector___len__(self)
    def pop(self): return _mmut.TreeVector_pop(self)
    def __getslice__(self, *args): return _mmut.TreeVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.TreeVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.TreeVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.TreeVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.TreeVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.TreeVector___setitem__(self, *args)
    def append(self, *args): return _mmut.TreeVector_append(self, *args)
    def empty(self): return _mmut.TreeVector_empty(self)
    def size(self): return _mmut.TreeVector_size(self)
    def clear(self): return _mmut.TreeVector_clear(self)
    def swap(self, *args): return _mmut.TreeVector_swap(self, *args)
    def get_allocator(self): return _mmut.TreeVector_get_allocator(self)
    def begin(self): return _mmut.TreeVector_begin(self)
    def end(self): return _mmut.TreeVector_end(self)
    def rbegin(self): return _mmut.TreeVector_rbegin(self)
    def rend(self): return _mmut.TreeVector_rend(self)
    def pop_back(self): return _mmut.TreeVector_pop_back(self)
    def erase(self, *args): return _mmut.TreeVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_TreeVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.TreeVector_push_back(self, *args)
    def front(self): return _mmut.TreeVector_front(self)
    def back(self): return _mmut.TreeVector_back(self)
    def assign(self, *args): return _mmut.TreeVector_assign(self, *args)
    def resize(self, *args): return _mmut.TreeVector_resize(self, *args)
    def insert(self, *args): return _mmut.TreeVector_insert(self, *args)
    def reserve(self, *args): return _mmut.TreeVector_reserve(self, *args)
    def capacity(self): return _mmut.TreeVector_capacity(self)
    __swig_destroy__ = _mmut.delete_TreeVector
    __del__ = lambda self : None;
TreeVector_swigregister = _mmut.TreeVector_swigregister
TreeVector_swigregister(TreeVector)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.StringVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.StringVector___nonzero__(self)
    def __bool__(self): return _mmut.StringVector___bool__(self)
    def __len__(self): return _mmut.StringVector___len__(self)
    def pop(self): return _mmut.StringVector_pop(self)
    def __getslice__(self, *args): return _mmut.StringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.StringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.StringVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.StringVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.StringVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.StringVector___setitem__(self, *args)
    def append(self, *args): return _mmut.StringVector_append(self, *args)
    def empty(self): return _mmut.StringVector_empty(self)
    def size(self): return _mmut.StringVector_size(self)
    def clear(self): return _mmut.StringVector_clear(self)
    def swap(self, *args): return _mmut.StringVector_swap(self, *args)
    def get_allocator(self): return _mmut.StringVector_get_allocator(self)
    def begin(self): return _mmut.StringVector_begin(self)
    def end(self): return _mmut.StringVector_end(self)
    def rbegin(self): return _mmut.StringVector_rbegin(self)
    def rend(self): return _mmut.StringVector_rend(self)
    def pop_back(self): return _mmut.StringVector_pop_back(self)
    def erase(self, *args): return _mmut.StringVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_StringVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.StringVector_push_back(self, *args)
    def front(self): return _mmut.StringVector_front(self)
    def back(self): return _mmut.StringVector_back(self)
    def assign(self, *args): return _mmut.StringVector_assign(self, *args)
    def resize(self, *args): return _mmut.StringVector_resize(self, *args)
    def insert(self, *args): return _mmut.StringVector_insert(self, *args)
    def reserve(self, *args): return _mmut.StringVector_reserve(self, *args)
    def capacity(self): return _mmut.StringVector_capacity(self)
    __swig_destroy__ = _mmut.delete_StringVector
    __del__ = lambda self : None;
StringVector_swigregister = _mmut.StringVector_swigregister
StringVector_swigregister(StringVector)

class bond_pair_cmp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bond_pair_cmp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bond_pair_cmp, name)
    __repr__ = _swig_repr
    def __call__(self, *args): return _mmut.bond_pair_cmp___call__(self, *args)
    def __init__(self): 
        this = _mmut.new_bond_pair_cmp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_bond_pair_cmp
    __del__ = lambda self : None;
bond_pair_cmp_swigregister = _mmut.bond_pair_cmp_swigregister
bond_pair_cmp_swigregister(bond_pair_cmp)

class TreeVertex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TreeVertex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TreeVertex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_TreeVertex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_TreeVertex
    __del__ = lambda self : None;
    def SetParentID(self, *args): return _mmut.TreeVertex_SetParentID(self, *args)
    def SetID(self, *args): return _mmut.TreeVertex_SetID(self, *args)
    def SetCoord(self, *args): return _mmut.TreeVertex_SetCoord(self, *args)
    def SetDummy(self, *args): return _mmut.TreeVertex_SetDummy(self, *args)
    def SetAngles(self): return _mmut.TreeVertex_SetAngles(self)
    __swig_setmethods__["Dummy"] = _mmut.TreeVertex_Dummy_set
    __swig_getmethods__["Dummy"] = _mmut.TreeVertex_Dummy_get
    if _newclass:Dummy = _swig_property(_mmut.TreeVertex_Dummy_get, _mmut.TreeVertex_Dummy_set)
    __swig_setmethods__["Dummy2"] = _mmut.TreeVertex_Dummy2_set
    __swig_getmethods__["Dummy2"] = _mmut.TreeVertex_Dummy2_get
    if _newclass:Dummy2 = _swig_property(_mmut.TreeVertex_Dummy2_get, _mmut.TreeVertex_Dummy2_set)
    def GetCoord(self): return _mmut.TreeVertex_GetCoord(self)
    def SetParentDistance(self, *args): return _mmut.TreeVertex_SetParentDistance(self, *args)
    def SetParentBondAngle(self, *args): return _mmut.TreeVertex_SetParentBondAngle(self, *args)
    def SetParentDihedralAngle(self, *args): return _mmut.TreeVertex_SetParentDihedralAngle(self, *args)
    def AddParentDistance(self, *args): return _mmut.TreeVertex_AddParentDistance(self, *args)
    def AddParentBondAngle(self, *args): return _mmut.TreeVertex_AddParentBondAngle(self, *args)
    def AddParentDihedralAngle(self, *args): return _mmut.TreeVertex_AddParentDihedralAngle(self, *args)
    def SetParent(self, *args): return _mmut.TreeVertex_SetParent(self, *args)
    def AddChild(self, *args): return _mmut.TreeVertex_AddChild(self, *args)
    def AddExternalChild(self, *args): return _mmut.TreeVertex_AddExternalChild(self, *args)
    def GetParentID(self): return _mmut.TreeVertex_GetParentID(self)
    def GetID(self): return _mmut.TreeVertex_GetID(self)
    def GetParent(self): return _mmut.TreeVertex_GetParent(self)
    def GetChildren(self): return _mmut.TreeVertex_GetChildren(self)
    def GetChild(self, *args): return _mmut.TreeVertex_GetChild(self, *args)
    def GetExternalChild(self, *args): return _mmut.TreeVertex_GetExternalChild(self, *args)
    def GetNumberOfChildren(self): return _mmut.TreeVertex_GetNumberOfChildren(self)
    def GetNumberOfExternalChildren(self): return _mmut.TreeVertex_GetNumberOfExternalChildren(self)
    def PrintTree(self): return _mmut.TreeVertex_PrintTree(self)
    def FindDepth(self): return _mmut.TreeVertex_FindDepth(self)
    def GetParentDistance(self): return _mmut.TreeVertex_GetParentDistance(self)
    def GetParentBondAngle(self): return _mmut.TreeVertex_GetParentBondAngle(self)
    def GetParentDihedralAngle(self): return _mmut.TreeVertex_GetParentDihedralAngle(self)
    def GetBranch(self): return _mmut.TreeVertex_GetBranch(self)
    def GetNumberOfDescendants(self): return _mmut.TreeVertex_GetNumberOfDescendants(self)
    def GetDescendants(self, *args): return _mmut.TreeVertex_GetDescendants(self, *args)
    def GetNonDescendants(self, *args): return _mmut.TreeVertex_GetNonDescendants(self, *args)
TreeVertex_swigregister = _mmut.TreeVertex_swigregister
TreeVertex_swigregister(TreeVertex)

class Tree(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Tree, name)
    __repr__ = _swig_repr
    def SetBondsAnglesTorsions(self, *args): return _mmut.Tree_SetBondsAnglesTorsions(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_Tree(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Tree
    __del__ = lambda self : None;
    def SetCoords(self, *args): return _mmut.Tree_SetCoords(self, *args)
    def Print(self): return _mmut.Tree_Print(self)
    def FindMaxDepth(self): return _mmut.Tree_FindMaxDepth(self)
    __swig_setmethods__["extra_bonded_pairs"] = _mmut.Tree_extra_bonded_pairs_set
    __swig_getmethods__["extra_bonded_pairs"] = _mmut.Tree_extra_bonded_pairs_get
    if _newclass:extra_bonded_pairs = _swig_property(_mmut.Tree_extra_bonded_pairs_get, _mmut.Tree_extra_bonded_pairs_set)
    def PrintZMatrix(self, *args): return _mmut.Tree_PrintZMatrix(self, *args)
    def GetNumberOfVertices(self): return _mmut.Tree_GetNumberOfVertices(self)
    def GetCoord(self, *args): return _mmut.Tree_GetCoord(self, *args)
    def GetCoords(self, permuted=False): return _mmut.Tree_GetCoords(self, permuted)
    def GetCartesian(self, *args): return _mmut.Tree_GetCartesian(self, *args)
    def GetAllCartesians(self, permuted=False): return _mmut.Tree_GetAllCartesians(self, permuted)
    def RotateAboutBond(self, *args): return _mmut.Tree_RotateAboutBond(self, *args)
    def FindLongBranches(self, *args): return _mmut.Tree_FindLongBranches(self, *args)
    def AddVertex(self, *args): return _mmut.Tree_AddVertex(self, *args)
    def SetDihedralAngle(self, *args): return _mmut.Tree_SetDihedralAngle(self, *args)
    def ForceEarlyConnection(self, *args): return _mmut.Tree_ForceEarlyConnection(self, *args)
    def GetAllIDs(self): return _mmut.Tree_GetAllIDs(self)
    def GetAllParentIDs(self): return _mmut.Tree_GetAllParentIDs(self)
Tree_swigregister = _mmut.Tree_swigregister
Tree_swigregister(Tree)

class intp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intp, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_intp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_intp
    __del__ = lambda self : None;
    def assign(self, *args): return _mmut.intp_assign(self, *args)
    def value(self): return _mmut.intp_value(self)
    def cast(self): return _mmut.intp_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.intp_frompointer
    if _newclass:frompointer = staticmethod(_mmut.intp_frompointer)
intp_swigregister = _mmut.intp_swigregister
intp_swigregister(intp)

def intp_frompointer(*args):
  return _mmut.intp_frompointer(*args)
intp_frompointer = _mmut.intp_frompointer

class doublep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doublep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doublep, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_doublep()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_doublep
    __del__ = lambda self : None;
    def assign(self, *args): return _mmut.doublep_assign(self, *args)
    def value(self): return _mmut.doublep_value(self)
    def cast(self): return _mmut.doublep_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.doublep_frompointer
    if _newclass:frompointer = staticmethod(_mmut.doublep_frompointer)
doublep_swigregister = _mmut.doublep_swigregister
doublep_swigregister(doublep)

def doublep_frompointer(*args):
  return _mmut.doublep_frompointer(*args)
doublep_frompointer = _mmut.doublep_frompointer

class floatp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floatp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floatp, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_floatp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_floatp
    __del__ = lambda self : None;
    def assign(self, *args): return _mmut.floatp_assign(self, *args)
    def value(self): return _mmut.floatp_value(self)
    def cast(self): return _mmut.floatp_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.floatp_frompointer
    if _newclass:frompointer = staticmethod(_mmut.floatp_frompointer)
floatp_swigregister = _mmut.floatp_swigregister
floatp_swigregister(floatp)

def floatp_frompointer(*args):
  return _mmut.floatp_frompointer(*args)
floatp_frompointer = _mmut.floatp_frompointer

class inta(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, inta, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, inta, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_inta(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_inta
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _mmut.inta___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.inta___setitem__(self, *args)
    def cast(self): return _mmut.inta_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.inta_frompointer
    if _newclass:frompointer = staticmethod(_mmut.inta_frompointer)
inta_swigregister = _mmut.inta_swigregister
inta_swigregister(inta)

def inta_frompointer(*args):
  return _mmut.inta_frompointer(*args)
inta_frompointer = _mmut.inta_frompointer

class doublea(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doublea, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doublea, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_doublea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_doublea
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _mmut.doublea___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.doublea___setitem__(self, *args)
    def cast(self): return _mmut.doublea_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.doublea_frompointer
    if _newclass:frompointer = staticmethod(_mmut.doublea_frompointer)
doublea_swigregister = _mmut.doublea_swigregister
doublea_swigregister(doublea)

def doublea_frompointer(*args):
  return _mmut.doublea_frompointer(*args)
doublea_frompointer = _mmut.doublea_frompointer

class floata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floata, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_floata(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_floata
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _mmut.floata___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.floata___setitem__(self, *args)
    def cast(self): return _mmut.floata_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.floata_frompointer
    if _newclass:frompointer = staticmethod(_mmut.floata_frompointer)
floata_swigregister = _mmut.floata_swigregister
floata_swigregister(floata)

def floata_frompointer(*args):
  return _mmut.floata_frompointer(*args)
floata_frompointer = _mmut.floata_frompointer

class FloatVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.FloatVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.FloatVector___nonzero__(self)
    def __bool__(self): return _mmut.FloatVector___bool__(self)
    def __len__(self): return _mmut.FloatVector___len__(self)
    def pop(self): return _mmut.FloatVector_pop(self)
    def __getslice__(self, *args): return _mmut.FloatVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.FloatVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.FloatVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.FloatVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.FloatVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.FloatVector___setitem__(self, *args)
    def append(self, *args): return _mmut.FloatVector_append(self, *args)
    def empty(self): return _mmut.FloatVector_empty(self)
    def size(self): return _mmut.FloatVector_size(self)
    def clear(self): return _mmut.FloatVector_clear(self)
    def swap(self, *args): return _mmut.FloatVector_swap(self, *args)
    def get_allocator(self): return _mmut.FloatVector_get_allocator(self)
    def begin(self): return _mmut.FloatVector_begin(self)
    def end(self): return _mmut.FloatVector_end(self)
    def rbegin(self): return _mmut.FloatVector_rbegin(self)
    def rend(self): return _mmut.FloatVector_rend(self)
    def pop_back(self): return _mmut.FloatVector_pop_back(self)
    def erase(self, *args): return _mmut.FloatVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_FloatVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.FloatVector_push_back(self, *args)
    def front(self): return _mmut.FloatVector_front(self)
    def back(self): return _mmut.FloatVector_back(self)
    def assign(self, *args): return _mmut.FloatVector_assign(self, *args)
    def resize(self, *args): return _mmut.FloatVector_resize(self, *args)
    def insert(self, *args): return _mmut.FloatVector_insert(self, *args)
    def reserve(self, *args): return _mmut.FloatVector_reserve(self, *args)
    def capacity(self): return _mmut.FloatVector_capacity(self)
    __swig_destroy__ = _mmut.delete_FloatVector
    __del__ = lambda self : None;
FloatVector_swigregister = _mmut.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

class map_string_string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, map_string_string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, map_string_string, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.map_string_string_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.map_string_string___nonzero__(self)
    def __bool__(self): return _mmut.map_string_string___bool__(self)
    def __len__(self): return _mmut.map_string_string___len__(self)
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args): return _mmut.map_string_string___getitem__(self, *args)
    def __delitem__(self, *args): return _mmut.map_string_string___delitem__(self, *args)
    def has_key(self, *args): return _mmut.map_string_string_has_key(self, *args)
    def keys(self): return _mmut.map_string_string_keys(self)
    def values(self): return _mmut.map_string_string_values(self)
    def items(self): return _mmut.map_string_string_items(self)
    def __contains__(self, *args): return _mmut.map_string_string___contains__(self, *args)
    def key_iterator(self): return _mmut.map_string_string_key_iterator(self)
    def value_iterator(self): return _mmut.map_string_string_value_iterator(self)
    def __setitem__(self, *args): return _mmut.map_string_string___setitem__(self, *args)
    def asdict(self): return _mmut.map_string_string_asdict(self)
    def __init__(self, *args): 
        this = _mmut.new_map_string_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _mmut.map_string_string_empty(self)
    def size(self): return _mmut.map_string_string_size(self)
    def clear(self): return _mmut.map_string_string_clear(self)
    def swap(self, *args): return _mmut.map_string_string_swap(self, *args)
    def get_allocator(self): return _mmut.map_string_string_get_allocator(self)
    def begin(self): return _mmut.map_string_string_begin(self)
    def end(self): return _mmut.map_string_string_end(self)
    def rbegin(self): return _mmut.map_string_string_rbegin(self)
    def rend(self): return _mmut.map_string_string_rend(self)
    def count(self, *args): return _mmut.map_string_string_count(self, *args)
    def erase(self, *args): return _mmut.map_string_string_erase(self, *args)
    def find(self, *args): return _mmut.map_string_string_find(self, *args)
    def lower_bound(self, *args): return _mmut.map_string_string_lower_bound(self, *args)
    def upper_bound(self, *args): return _mmut.map_string_string_upper_bound(self, *args)
    __swig_destroy__ = _mmut.delete_map_string_string
    __del__ = lambda self : None;
map_string_string_swigregister = _mmut.map_string_string_swigregister
map_string_string_swigregister(map_string_string)

class map_int_string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, map_int_string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, map_int_string, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.map_int_string_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.map_int_string___nonzero__(self)
    def __bool__(self): return _mmut.map_int_string___bool__(self)
    def __len__(self): return _mmut.map_int_string___len__(self)
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args): return _mmut.map_int_string___getitem__(self, *args)
    def __delitem__(self, *args): return _mmut.map_int_string___delitem__(self, *args)
    def has_key(self, *args): return _mmut.map_int_string_has_key(self, *args)
    def keys(self): return _mmut.map_int_string_keys(self)
    def values(self): return _mmut.map_int_string_values(self)
    def items(self): return _mmut.map_int_string_items(self)
    def __contains__(self, *args): return _mmut.map_int_string___contains__(self, *args)
    def key_iterator(self): return _mmut.map_int_string_key_iterator(self)
    def value_iterator(self): return _mmut.map_int_string_value_iterator(self)
    def __setitem__(self, *args): return _mmut.map_int_string___setitem__(self, *args)
    def asdict(self): return _mmut.map_int_string_asdict(self)
    def __init__(self, *args): 
        this = _mmut.new_map_int_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _mmut.map_int_string_empty(self)
    def size(self): return _mmut.map_int_string_size(self)
    def clear(self): return _mmut.map_int_string_clear(self)
    def swap(self, *args): return _mmut.map_int_string_swap(self, *args)
    def get_allocator(self): return _mmut.map_int_string_get_allocator(self)
    def begin(self): return _mmut.map_int_string_begin(self)
    def end(self): return _mmut.map_int_string_end(self)
    def rbegin(self): return _mmut.map_int_string_rbegin(self)
    def rend(self): return _mmut.map_int_string_rend(self)
    def count(self, *args): return _mmut.map_int_string_count(self, *args)
    def erase(self, *args): return _mmut.map_int_string_erase(self, *args)
    def find(self, *args): return _mmut.map_int_string_find(self, *args)
    def lower_bound(self, *args): return _mmut.map_int_string_lower_bound(self, *args)
    def upper_bound(self, *args): return _mmut.map_int_string_upper_bound(self, *args)
    __swig_destroy__ = _mmut.delete_map_int_string
    __del__ = lambda self : None;
map_int_string_swigregister = _mmut.map_int_string_swigregister
map_int_string_swigregister(map_int_string)


def InitMatType():
  return _mmut.InitMatType()
InitMatType = _mmut.InitMatType

def mround(*args):
  return _mmut.mround(*args)
mround = _mmut.mround

def ifloor(*args):
  return _mmut.ifloor(*args)
ifloor = _mmut.ifloor

def Abs(*args):
  return _mmut.Abs(*args)
Abs = _mmut.Abs

def ISwap(*args):
  return _mmut.ISwap(*args)
ISwap = _mmut.ISwap

def WSwap(*args):
  return _mmut.WSwap(*args)
WSwap = _mmut.WSwap

def BSwap(*args):
  return _mmut.BSwap(*args)
BSwap = _mmut.BSwap

def OSwap(*args):
  return _mmut.OSwap(*args)
OSwap = _mmut.OSwap

def LSwap(*args):
  return _mmut.LSwap(*args)
LSwap = _mmut.LSwap

def RSwap(*args):
  return _mmut.RSwap(*args)
RSwap = _mmut.RSwap

def RMax(*args):
  return _mmut.RMax(*args)
RMax = _mmut.RMax

def LMax(*args):
  return _mmut.LMax(*args)
LMax = _mmut.LMax

def WMax(*args):
  return _mmut.WMax(*args)
WMax = _mmut.WMax

def IMax(*args):
  return _mmut.IMax(*args)
IMax = _mmut.IMax

def RMin(*args):
  return _mmut.RMin(*args)
RMin = _mmut.RMin

def LMin(*args):
  return _mmut.LMin(*args)
LMin = _mmut.LMin

def WMin(*args):
  return _mmut.WMin(*args)
WMin = _mmut.WMin

def IMin(*args):
  return _mmut.IMin(*args)
IMin = _mmut.IMin

def fsign(*args):
  return _mmut.fsign(*args)
fsign = _mmut.fsign

def GetVectorMemory(*args):
  return _mmut.GetVectorMemory(*args)
GetVectorMemory = _mmut.GetVectorMemory

def FreeVectorMemory(*args):
  return _mmut.FreeVectorMemory(*args)
FreeVectorMemory = _mmut.FreeVectorMemory

def GetMatrixMemory(*args):
  return _mmut.GetMatrixMemory(*args)
GetMatrixMemory = _mmut.GetMatrixMemory

def FreeMatrixMemory(*args):
  return _mmut.FreeMatrixMemory(*args)
FreeMatrixMemory = _mmut.FreeMatrixMemory

def GetMatrix3Memory(*args):
  return _mmut.GetMatrix3Memory(*args)
GetMatrix3Memory = _mmut.GetMatrix3Memory

def FreeMatrix3Memory(*args):
  return _mmut.FreeMatrix3Memory(*args)
FreeMatrix3Memory = _mmut.FreeMatrix3Memory

def MachinEps():
  return _mmut.MachinEps()
MachinEps = _mmut.MachinEps

def floatMachinEps():
  return _mmut.floatMachinEps()
floatMachinEps = _mmut.floatMachinEps

def frac(*args):
  return _mmut.frac(*args)
frac = _mmut.frac

def mod(*args):
  return _mmut.mod(*args)
mod = _mmut.mod

def Pow(*args):
  return _mmut.Pow(*args)
Pow = _mmut.Pow

def Pow1(*args):
  return _mmut.Pow1(*args)
Pow1 = _mmut.Pow1

def Exp(*args):
  return _mmut.Exp(*args)
Exp = _mmut.Exp

def Odd(*args):
  return _mmut.Odd(*args)
Odd = _mmut.Odd

def HexValL(*args):
  return _mmut.HexValL(*args)
HexValL = _mmut.HexValL

def OctValL(*args):
  return _mmut.OctValL(*args)
OctValL = _mmut.OctValL

def BinValL(*args):
  return _mmut.BinValL(*args)
BinValL = _mmut.BinValL

def BinValS(*args):
  return _mmut.BinValS(*args)
BinValS = _mmut.BinValS

def ParamStr(*args):
  return _mmut.ParamStr(*args)
ParamStr = _mmut.ParamStr

def CreateCopy(*args):
  return _mmut.CreateCopy(*args)
CreateCopy = _mmut.CreateCopy

def CreateCopy_n(*args):
  return _mmut.CreateCopy_n(*args)
CreateCopy_n = _mmut.CreateCopy_n

def CreateConcat(*args):
  return _mmut.CreateConcat(*args)
CreateConcat = _mmut.CreateConcat

def CreateCopCat(*args):
  return _mmut.CreateCopCat(*args)
CreateCopCat = _mmut.CreateCopCat

def LastOccurence(*args):
  return _mmut.LastOccurence(*args)
LastOccurence = _mmut.LastOccurence

def FirstOccurence(*args):
  return _mmut.FirstOccurence(*args)
FirstOccurence = _mmut.FirstOccurence

def indexOf(*args):
  return _mmut.indexOf(*args)
indexOf = _mmut.indexOf

def LowerCase(*args):
  return _mmut.LowerCase(*args)
LowerCase = _mmut.LowerCase

def UpperCase(*args):
  return _mmut.UpperCase(*args)
UpperCase = _mmut.UpperCase

def GetString(*args):
  return _mmut.GetString(*args)
GetString = _mmut.GetString

def GetStrTer(*args):
  return _mmut.GetStrTer(*args)
GetStrTer = _mmut.GetStrTer

def GetStrTerWin32File(*args):
  return _mmut.GetStrTerWin32File(*args)
GetStrTerWin32File = _mmut.GetStrTerWin32File

def strcpy_n(*args):
  return _mmut.strcpy_n(*args)
strcpy_n = _mmut.strcpy_n

def strcpy_n1(*args):
  return _mmut.strcpy_n1(*args)
strcpy_n1 = _mmut.strcpy_n1

def strcpy_nr(*args):
  return _mmut.strcpy_nr(*args)
strcpy_nr = _mmut.strcpy_nr

def strcpy_ns(*args):
  return _mmut.strcpy_ns(*args)
strcpy_ns = _mmut.strcpy_ns

def strcpy_cs(*args):
  return _mmut.strcpy_cs(*args)
strcpy_cs = _mmut.strcpy_cs

def strcpy_ncs(*args):
  return _mmut.strcpy_ncs(*args)
strcpy_ncs = _mmut.strcpy_ncs

def strcpy_css(*args):
  return _mmut.strcpy_css(*args)
strcpy_css = _mmut.strcpy_css

def strcpy_ncss(*args):
  return _mmut.strcpy_ncss(*args)
strcpy_ncss = _mmut.strcpy_ncss

def strcpy_n0(*args):
  return _mmut.strcpy_n0(*args)
strcpy_n0 = _mmut.strcpy_n0

def strlen_des(*args):
  return _mmut.strlen_des(*args)
strlen_des = _mmut.strlen_des

def strcpy_des(*args):
  return _mmut.strcpy_des(*args)
strcpy_des = _mmut.strcpy_des

def strcat_des(*args):
  return _mmut.strcat_des(*args)
strcat_des = _mmut.strcat_des

def PadSpaces(*args):
  return _mmut.PadSpaces(*args)
PadSpaces = _mmut.PadSpaces
SCUTKEY_BEGIN = _mmut.SCUTKEY_BEGIN
SCUTKEY_END = _mmut.SCUTKEY_END
SCUTKEY_BEGEND = _mmut.SCUTKEY_BEGEND

def CutSpaces(*args):
  return _mmut.CutSpaces(*args)
CutSpaces = _mmut.CutSpaces

def DelSpaces(*args):
  return _mmut.DelSpaces(*args)
DelSpaces = _mmut.DelSpaces

def EnforceSpaces(*args):
  return _mmut.EnforceSpaces(*args)
EnforceSpaces = _mmut.EnforceSpaces

def set_new_float_unibin():
  return _mmut.set_new_float_unibin()
set_new_float_unibin = _mmut.set_new_float_unibin

def is_new_float_unibin():
  return _mmut.is_new_float_unibin()
is_new_float_unibin = _mmut.is_new_float_unibin

def set_old_float_unibin():
  return _mmut.set_old_float_unibin()
set_old_float_unibin = _mmut.set_old_float_unibin

def __modify4():
  return _mmut.__modify4()
__modify4 = _mmut.__modify4

def int2UniBin(*args):
  return _mmut.int2UniBin(*args)
int2UniBin = _mmut.int2UniBin

def short2UniBin(*args):
  return _mmut.short2UniBin(*args)
short2UniBin = _mmut.short2UniBin

def long2UniBin(*args):
  return _mmut.long2UniBin(*args)
long2UniBin = _mmut.long2UniBin

def word2UniBin(*args):
  return _mmut.word2UniBin(*args)
word2UniBin = _mmut.word2UniBin

def real2UniBin(*args):
  return _mmut.real2UniBin(*args)
real2UniBin = _mmut.real2UniBin

def float2UniBin(*args):
  return _mmut.float2UniBin(*args)
float2UniBin = _mmut.float2UniBin

def shortreal2UniBin(*args):
  return _mmut.shortreal2UniBin(*args)
shortreal2UniBin = _mmut.shortreal2UniBin

def UniBin2int(*args):
  return _mmut.UniBin2int(*args)
UniBin2int = _mmut.UniBin2int

def UniBin2short(*args):
  return _mmut.UniBin2short(*args)
UniBin2short = _mmut.UniBin2short

def UniBin2long(*args):
  return _mmut.UniBin2long(*args)
UniBin2long = _mmut.UniBin2long

def UniBin2word(*args):
  return _mmut.UniBin2word(*args)
UniBin2word = _mmut.UniBin2word

def UniBin2real(*args):
  return _mmut.UniBin2real(*args)
UniBin2real = _mmut.UniBin2real

def UniBin2shortreal(*args):
  return _mmut.UniBin2shortreal(*args)
UniBin2shortreal = _mmut.UniBin2shortreal

def UniBin2float(*args):
  return _mmut.UniBin2float(*args)
UniBin2float = _mmut.UniBin2float

def mem_write(*args):
  return _mmut.mem_write(*args)
mem_write = _mmut.mem_write

def mem_write_byte(*args):
  return _mmut.mem_write_byte(*args)
mem_write_byte = _mmut.mem_write_byte

def mem_read(*args):
  return _mmut.mem_read(*args)
mem_read = _mmut.mem_read

def mem_read_byte(*args):
  return _mmut.mem_read_byte(*args)
mem_read_byte = _mmut.mem_read_byte
MAJOR_VERSION = _mmut.MAJOR_VERSION
MINOR_VERSION = _mmut.MINOR_VERSION
MICRO_VERSION = _mmut.MICRO_VERSION
PRNK_Silent = _mmut.PRNK_Silent
PRNK_SimRWBROOK = _mmut.PRNK_SimRWBROOK
Error_EmptyCIF = _mmut.Error_EmptyCIF
Error_NoError = _mmut.Error_NoError
Error_Ok = _mmut.Error_Ok
Error_WrongSection = _mmut.Error_WrongSection
Error_WrongChainID = _mmut.Error_WrongChainID
Error_WrongEntryID = _mmut.Error_WrongEntryID
Error_SEQRES_serNum = _mmut.Error_SEQRES_serNum
Error_SEQRES_numRes = _mmut.Error_SEQRES_numRes
Error_SEQRES_extraRes = _mmut.Error_SEQRES_extraRes
Error_NCSM_Unrecognized = _mmut.Error_NCSM_Unrecognized
Error_NCSM_AlreadySet = _mmut.Error_NCSM_AlreadySet
Error_NCSM_WrongSerial = _mmut.Error_NCSM_WrongSerial
Error_NCSM_UnmatchIG = _mmut.Error_NCSM_UnmatchIG
Error_ATOM_Unrecognized = _mmut.Error_ATOM_Unrecognized
Error_ATOM_AlreadySet = _mmut.Error_ATOM_AlreadySet
Error_ATOM_NoResidue = _mmut.Error_ATOM_NoResidue
Error_ATOM_Unmatch = _mmut.Error_ATOM_Unmatch
Error_CantOpenFile = _mmut.Error_CantOpenFile
Error_UnrecognizedInteger = _mmut.Error_UnrecognizedInteger
Error_WrongModelNo = _mmut.Error_WrongModelNo
Error_DuplicatedModel = _mmut.Error_DuplicatedModel
Error_NoModel = _mmut.Error_NoModel
Error_ForeignFile = _mmut.Error_ForeignFile
Error_WrongEdition = _mmut.Error_WrongEdition
Error_NotACIFFile = _mmut.Error_NotACIFFile
Error_NoData = _mmut.Error_NoData
Error_NoLoop = _mmut.Error_NoLoop
Error_NoStruct = _mmut.Error_NoStruct
Error_UnrecognCIFItems = _mmut.Error_UnrecognCIFItems
Error_MissingCIFField = _mmut.Error_MissingCIFField
Error_EmptyCIFLoop = _mmut.Error_EmptyCIFLoop
Error_EmptyCIFStruct = _mmut.Error_EmptyCIFStruct
Error_UnexpEndOfCIF = _mmut.Error_UnexpEndOfCIF
Error_MissgCIFLoopField = _mmut.Error_MissgCIFLoopField
Error_NotACIFStructure = _mmut.Error_NotACIFStructure
Error_NotACIFLoop = _mmut.Error_NotACIFLoop
Error_UnrecognizedReal = _mmut.Error_UnrecognizedReal
Error_NoSheetID = _mmut.Error_NoSheetID
Error_WrongSheetID = _mmut.Error_WrongSheetID
Error_WrongStrandNo = _mmut.Error_WrongStrandNo
Error_WrongNumberOfStrands = _mmut.Error_WrongNumberOfStrands
Error_WrongSheetOrder = _mmut.Error_WrongSheetOrder
Error_HBondInconsistency = _mmut.Error_HBondInconsistency
Error_EmptyResidueName = _mmut.Error_EmptyResidueName
Error_DuplicateSeqNum = _mmut.Error_DuplicateSeqNum
Error_NoLogicalName = _mmut.Error_NoLogicalName
Error_EmptyFile = _mmut.Error_EmptyFile
Error_Unknown = _mmut.Error_Unknown
Error_CIF_EmptyRow = _mmut.Error_CIF_EmptyRow
Error_GeneralError1 = _mmut.Error_GeneralError1
ClassID_Template = _mmut.ClassID_Template
ClassID_String = _mmut.ClassID_String
ClassID_ObsLine = _mmut.ClassID_ObsLine
ClassID_TitleLine = _mmut.ClassID_TitleLine
ClassID_CAVEAT = _mmut.ClassID_CAVEAT
ClassID_Compound = _mmut.ClassID_Compound
ClassID_Source = _mmut.ClassID_Source
ClassID_ExpData = _mmut.ClassID_ExpData
ClassID_MdlType = _mmut.ClassID_MdlType
ClassID_Author = _mmut.ClassID_Author
ClassID_RevData = _mmut.ClassID_RevData
ClassID_Supersede = _mmut.ClassID_Supersede
ClassID_Journal = _mmut.ClassID_Journal
ClassID_Remark = _mmut.ClassID_Remark
ClassID_DBReference = _mmut.ClassID_DBReference
ClassID_SeqAdv = _mmut.ClassID_SeqAdv
ClassID_ModRes = _mmut.ClassID_ModRes
ClassID_Het = _mmut.ClassID_Het
ClassID_NCSMatrix = _mmut.ClassID_NCSMatrix
ClassID_TVect = _mmut.ClassID_TVect
ClassID_Helix = _mmut.ClassID_Helix
ClassID_Turn = _mmut.ClassID_Turn
ClassID_Link = _mmut.ClassID_Link
ClassID_LinkR = _mmut.ClassID_LinkR
ClassID_CisPep = _mmut.ClassID_CisPep
class Mask(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mask, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Mask, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_Mask()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Mask
    __del__ = lambda self : None;
    def SetMaskBit(self, *args): return _mmut.Mask_SetMaskBit(self, *args)
    def NewMask(self, *args): return _mmut.Mask_NewMask(self, *args)
    def CopyMask(self, *args): return _mmut.Mask_CopyMask(self, *args)
    def SetMask(self, *args): return _mmut.Mask_SetMask(self, *args)
    def RemoveMask(self, *args): return _mmut.Mask_RemoveMask(self, *args)
    def SelMask(self, *args): return _mmut.Mask_SelMask(self, *args)
    def XadMask(self, *args): return _mmut.Mask_XadMask(self, *args)
    def ClearMask(self): return _mmut.Mask_ClearMask(self)
    def NegMask(self): return _mmut.Mask_NegMask(self)
    def CheckMask(self, *args): return _mmut.Mask_CheckMask(self, *args)
    def isMask(self): return _mmut.Mask_isMask(self)
    def getLength(self): return _mmut.Mask_getLength(self)
    def Print(self, *args): return _mmut.Mask_Print(self, *args)
Mask_swigregister = _mmut.Mask_swigregister
Mask_swigregister(Mask)
cvar = _mmut.cvar
MinReal = cvar.MinReal
MaxReal = cvar.MaxReal
fMinReal = cvar.fMinReal
fMaxReal = cvar.fMaxReal
MinShortReal = cvar.MinShortReal
MaxShortReal = cvar.MaxShortReal
MaxInt = cvar.MaxInt
MinInt = cvar.MinInt
MaxWord = cvar.MaxWord
MaxInt4 = cvar.MaxInt4
MinInt4 = cvar.MinInt4
MaxWord4 = cvar.MaxWord4
Pi = cvar.Pi
Eu = cvar.Eu
ln10 = cvar.ln10
ANY_RES = cvar.ANY_RES

UDR_ATOM = _mmut.UDR_ATOM
UDR_RESIDUE = _mmut.UDR_RESIDUE
UDR_CHAIN = _mmut.UDR_CHAIN
UDR_MODEL = _mmut.UDR_MODEL
UDR_HIERARCHY = _mmut.UDR_HIERARCHY
UDRF_ATOM = _mmut.UDRF_ATOM
UDRF_RESIDUE = _mmut.UDRF_RESIDUE
UDRF_CHAIN = _mmut.UDRF_CHAIN
UDRF_MODEL = _mmut.UDRF_MODEL
UDRF_HIERARCHY = _mmut.UDRF_HIERARCHY
UDRF_MASK = _mmut.UDRF_MASK
class UDRegister(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UDRegister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UDRegister, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_UDRegister()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_UDRegister
    __del__ = lambda self : None;
    def RegisterUDInteger(self, *args): return _mmut.UDRegister_RegisterUDInteger(self, *args)
    def RegisterUDReal(self, *args): return _mmut.UDRegister_RegisterUDReal(self, *args)
    def RegisterUDString(self, *args): return _mmut.UDRegister_RegisterUDString(self, *args)
    def GetUDDHandle(self, *args): return _mmut.UDRegister_GetUDDHandle(self, *args)
UDRegister_swigregister = _mmut.UDRegister_swigregister
UDRegister_swigregister(UDRegister)

UDDATA_Ok = _mmut.UDDATA_Ok
UDDATA_WrongHandle = _mmut.UDDATA_WrongHandle
UDDATA_WrongUDRType = _mmut.UDDATA_WrongUDRType
UDDATA_NoData = _mmut.UDDATA_NoData
class UDData(Mask):
    __swig_setmethods__ = {}
    for _s in [Mask]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UDData, name, value)
    __swig_getmethods__ = {}
    for _s in [Mask]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UDData, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_UDData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_UDData
    __del__ = lambda self : None;
UDData_swigregister = _mmut.UDData_swigregister
UDData_swigregister(UDData)

class ProModel(UDData):
    __swig_setmethods__ = {}
    for _s in [UDData]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProModel, name, value)
    __swig_getmethods__ = {}
    for _s in [UDData]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProModel, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_ProModel()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_ProModel
    __del__ = lambda self : None;
    def GetEntryID(self): return _mmut.ProModel_GetEntryID(self)
    def SetEntryID(self, *args): return _mmut.ProModel_SetEntryID(self, *args)
    def AddChain(self, *args): return _mmut.ProModel_AddChain(self, *args)
    def GetCoordHierarchy(self): return _mmut.ProModel_GetCoordHierarchy(self)
    def GetNumberOfModels(self): return _mmut.ProModel_GetNumberOfModels(self)
    def GetNumberOfAllAtoms(self): return _mmut.ProModel_GetNumberOfAllAtoms(self)
    def GetAllAtoms(self): return _mmut.ProModel_GetAllAtoms(self)
    def GetSerNum(self): return _mmut.ProModel_GetSerNum(self)
    def ExpandAtomArray(self, *args): return _mmut.ProModel_ExpandAtomArray(self, *args)
    def AddAtomArray(self, *args): return _mmut.ProModel_AddAtomArray(self, *args)
ProModel_swigregister = _mmut.ProModel_swigregister
ProModel_swigregister(ProModel)

class ChainContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChainContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChainContainer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_ChainContainer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_ChainContainer
    __del__ = lambda self : None;
    def SetChain(self, *args): return _mmut.ChainContainer_SetChain(self, *args)
    def Get1stChainID(self): return _mmut.ChainContainer_Get1stChainID(self)
    def MoveByChainID(self, *args): return _mmut.ChainContainer_MoveByChainID(self, *args)
ChainContainer_swigregister = _mmut.ChainContainer_swigregister
ChainContainer_swigregister(ChainContainer)

class ContainerChain(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ContainerChain, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ContainerChain, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_ContainerChain(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetChain(self, *args): return _mmut.ContainerChain_SetChain(self, *args)
    __swig_destroy__ = _mmut.delete_ContainerChain
    __del__ = lambda self : None;
ContainerChain_swigregister = _mmut.ContainerChain_swigregister
ContainerChain_swigregister(ContainerChain)

class DBReference(ContainerChain):
    __swig_setmethods__ = {}
    for _s in [ContainerChain]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DBReference, name, value)
    __swig_getmethods__ = {}
    for _s in [ContainerChain]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DBReference, name)
    __repr__ = _swig_repr
    __swig_setmethods__["seqBeg"] = _mmut.DBReference_seqBeg_set
    __swig_getmethods__["seqBeg"] = _mmut.DBReference_seqBeg_get
    if _newclass:seqBeg = _swig_property(_mmut.DBReference_seqBeg_get, _mmut.DBReference_seqBeg_set)
    __swig_setmethods__["insBeg"] = _mmut.DBReference_insBeg_set
    __swig_getmethods__["insBeg"] = _mmut.DBReference_insBeg_get
    if _newclass:insBeg = _swig_property(_mmut.DBReference_insBeg_get, _mmut.DBReference_insBeg_set)
    __swig_setmethods__["seqEnd"] = _mmut.DBReference_seqEnd_set
    __swig_getmethods__["seqEnd"] = _mmut.DBReference_seqEnd_get
    if _newclass:seqEnd = _swig_property(_mmut.DBReference_seqEnd_get, _mmut.DBReference_seqEnd_set)
    __swig_setmethods__["insEnd"] = _mmut.DBReference_insEnd_set
    __swig_getmethods__["insEnd"] = _mmut.DBReference_insEnd_get
    if _newclass:insEnd = _swig_property(_mmut.DBReference_insEnd_get, _mmut.DBReference_insEnd_set)
    __swig_setmethods__["database"] = _mmut.DBReference_database_set
    __swig_getmethods__["database"] = _mmut.DBReference_database_get
    if _newclass:database = _swig_property(_mmut.DBReference_database_get, _mmut.DBReference_database_set)
    __swig_setmethods__["dbAccession"] = _mmut.DBReference_dbAccession_set
    __swig_getmethods__["dbAccession"] = _mmut.DBReference_dbAccession_get
    if _newclass:dbAccession = _swig_property(_mmut.DBReference_dbAccession_get, _mmut.DBReference_dbAccession_set)
    __swig_setmethods__["dbIdCode"] = _mmut.DBReference_dbIdCode_set
    __swig_getmethods__["dbIdCode"] = _mmut.DBReference_dbIdCode_get
    if _newclass:dbIdCode = _swig_property(_mmut.DBReference_dbIdCode_get, _mmut.DBReference_dbIdCode_set)
    __swig_setmethods__["dbseqBeg"] = _mmut.DBReference_dbseqBeg_set
    __swig_getmethods__["dbseqBeg"] = _mmut.DBReference_dbseqBeg_get
    if _newclass:dbseqBeg = _swig_property(_mmut.DBReference_dbseqBeg_get, _mmut.DBReference_dbseqBeg_set)
    __swig_setmethods__["dbinsBeg"] = _mmut.DBReference_dbinsBeg_set
    __swig_getmethods__["dbinsBeg"] = _mmut.DBReference_dbinsBeg_get
    if _newclass:dbinsBeg = _swig_property(_mmut.DBReference_dbinsBeg_get, _mmut.DBReference_dbinsBeg_set)
    __swig_setmethods__["dbseqEnd"] = _mmut.DBReference_dbseqEnd_set
    __swig_getmethods__["dbseqEnd"] = _mmut.DBReference_dbseqEnd_get
    if _newclass:dbseqEnd = _swig_property(_mmut.DBReference_dbseqEnd_get, _mmut.DBReference_dbseqEnd_set)
    __swig_setmethods__["dbinsEnd"] = _mmut.DBReference_dbinsEnd_set
    __swig_getmethods__["dbinsEnd"] = _mmut.DBReference_dbinsEnd_get
    if _newclass:dbinsEnd = _swig_property(_mmut.DBReference_dbinsEnd_get, _mmut.DBReference_dbinsEnd_set)
    def __init__(self, *args): 
        this = _mmut.new_DBReference(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_DBReference
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.DBReference_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.DBReference_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.DBReference_GetCIF(self, *args)
    def GetClassID(self): return _mmut.DBReference_GetClassID(self)
    def Copy(self, *args): return _mmut.DBReference_Copy(self, *args)
DBReference_swigregister = _mmut.DBReference_swigregister
DBReference_swigregister(DBReference)

class SeqAdv(ContainerChain):
    __swig_setmethods__ = {}
    for _s in [ContainerChain]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SeqAdv, name, value)
    __swig_getmethods__ = {}
    for _s in [ContainerChain]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SeqAdv, name)
    __repr__ = _swig_repr
    __swig_setmethods__["resName"] = _mmut.SeqAdv_resName_set
    __swig_getmethods__["resName"] = _mmut.SeqAdv_resName_get
    if _newclass:resName = _swig_property(_mmut.SeqAdv_resName_get, _mmut.SeqAdv_resName_set)
    __swig_setmethods__["seqNum"] = _mmut.SeqAdv_seqNum_set
    __swig_getmethods__["seqNum"] = _mmut.SeqAdv_seqNum_get
    if _newclass:seqNum = _swig_property(_mmut.SeqAdv_seqNum_get, _mmut.SeqAdv_seqNum_set)
    __swig_setmethods__["insCode"] = _mmut.SeqAdv_insCode_set
    __swig_getmethods__["insCode"] = _mmut.SeqAdv_insCode_get
    if _newclass:insCode = _swig_property(_mmut.SeqAdv_insCode_get, _mmut.SeqAdv_insCode_set)
    __swig_setmethods__["database"] = _mmut.SeqAdv_database_set
    __swig_getmethods__["database"] = _mmut.SeqAdv_database_get
    if _newclass:database = _swig_property(_mmut.SeqAdv_database_get, _mmut.SeqAdv_database_set)
    __swig_setmethods__["dbAccession"] = _mmut.SeqAdv_dbAccession_set
    __swig_getmethods__["dbAccession"] = _mmut.SeqAdv_dbAccession_get
    if _newclass:dbAccession = _swig_property(_mmut.SeqAdv_dbAccession_get, _mmut.SeqAdv_dbAccession_set)
    __swig_setmethods__["dbRes"] = _mmut.SeqAdv_dbRes_set
    __swig_getmethods__["dbRes"] = _mmut.SeqAdv_dbRes_get
    if _newclass:dbRes = _swig_property(_mmut.SeqAdv_dbRes_get, _mmut.SeqAdv_dbRes_set)
    __swig_setmethods__["dbSeq"] = _mmut.SeqAdv_dbSeq_set
    __swig_getmethods__["dbSeq"] = _mmut.SeqAdv_dbSeq_get
    if _newclass:dbSeq = _swig_property(_mmut.SeqAdv_dbSeq_get, _mmut.SeqAdv_dbSeq_set)
    __swig_setmethods__["conflict"] = _mmut.SeqAdv_conflict_set
    __swig_getmethods__["conflict"] = _mmut.SeqAdv_conflict_get
    if _newclass:conflict = _swig_property(_mmut.SeqAdv_conflict_get, _mmut.SeqAdv_conflict_set)
    def __init__(self, *args): 
        this = _mmut.new_SeqAdv(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_SeqAdv
    __del__ = lambda self : None;
    def ConvertPDBASCII(self, *args): return _mmut.SeqAdv_ConvertPDBASCII(self, *args)
    def MakeCIF(self, *args): return _mmut.SeqAdv_MakeCIF(self, *args)
    def GetCIF(self, *args): return _mmut.SeqAdv_GetCIF(self, *args)
    def GetClassID(self): return _mmut.SeqAdv_GetClassID(self)
    def Copy(self, *args): return _mmut.SeqAdv_Copy(self, *args)
SeqAdv_swigregister = _mmut.SeqAdv_swigregister
SeqAdv_swigregister(SeqAdv)

class SeqRes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SeqRes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SeqRes, name)
    __repr__ = _swig_repr
    __swig_setmethods__["numRes"] = _mmut.SeqRes_numRes_set
    __swig_getmethods__["numRes"] = _mmut.SeqRes_numRes_get
    if _newclass:numRes = _swig_property(_mmut.SeqRes_numRes_get, _mmut.SeqRes_numRes_set)
    __swig_setmethods__["resName"] = _mmut.SeqRes_resName_set
    __swig_getmethods__["resName"] = _mmut.SeqRes_resName_get
    if _newclass:resName = _swig_property(_mmut.SeqRes_resName_get, _mmut.SeqRes_resName_set)
    def __init__(self): 
        this = _mmut.new_SeqRes()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_SeqRes
    __del__ = lambda self : None;
    def SetChain(self, *args): return _mmut.SeqRes_SetChain(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.SeqRes_ConvertPDBASCII(self, *args)
    def MakeCIF(self, *args): return _mmut.SeqRes_MakeCIF(self, *args)
    def GetCIF(self, *args): return _mmut.SeqRes_GetCIF(self, *args)
    def Copy(self, *args): return _mmut.SeqRes_Copy(self, *args)
SeqRes_swigregister = _mmut.SeqRes_swigregister
SeqRes_swigregister(SeqRes)

class ModRes(ContainerChain):
    __swig_setmethods__ = {}
    for _s in [ContainerChain]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModRes, name, value)
    __swig_getmethods__ = {}
    for _s in [ContainerChain]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ModRes, name)
    __repr__ = _swig_repr
    __swig_setmethods__["resName"] = _mmut.ModRes_resName_set
    __swig_getmethods__["resName"] = _mmut.ModRes_resName_get
    if _newclass:resName = _swig_property(_mmut.ModRes_resName_get, _mmut.ModRes_resName_set)
    __swig_setmethods__["seqNum"] = _mmut.ModRes_seqNum_set
    __swig_getmethods__["seqNum"] = _mmut.ModRes_seqNum_get
    if _newclass:seqNum = _swig_property(_mmut.ModRes_seqNum_get, _mmut.ModRes_seqNum_set)
    __swig_setmethods__["insCode"] = _mmut.ModRes_insCode_set
    __swig_getmethods__["insCode"] = _mmut.ModRes_insCode_get
    if _newclass:insCode = _swig_property(_mmut.ModRes_insCode_get, _mmut.ModRes_insCode_set)
    __swig_setmethods__["stdRes"] = _mmut.ModRes_stdRes_set
    __swig_getmethods__["stdRes"] = _mmut.ModRes_stdRes_get
    if _newclass:stdRes = _swig_property(_mmut.ModRes_stdRes_get, _mmut.ModRes_stdRes_set)
    __swig_setmethods__["comment"] = _mmut.ModRes_comment_set
    __swig_getmethods__["comment"] = _mmut.ModRes_comment_get
    if _newclass:comment = _swig_property(_mmut.ModRes_comment_get, _mmut.ModRes_comment_set)
    def __init__(self, *args): 
        this = _mmut.new_ModRes(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_ModRes
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.ModRes_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.ModRes_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.ModRes_GetCIF(self, *args)
    def GetClassID(self): return _mmut.ModRes_GetClassID(self)
    def Copy(self, *args): return _mmut.ModRes_Copy(self, *args)
ModRes_swigregister = _mmut.ModRes_swigregister
ModRes_swigregister(ModRes)

class HetRec(ContainerChain):
    __swig_setmethods__ = {}
    for _s in [ContainerChain]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HetRec, name, value)
    __swig_getmethods__ = {}
    for _s in [ContainerChain]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HetRec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["hetID"] = _mmut.HetRec_hetID_set
    __swig_getmethods__["hetID"] = _mmut.HetRec_hetID_get
    if _newclass:hetID = _swig_property(_mmut.HetRec_hetID_get, _mmut.HetRec_hetID_set)
    __swig_setmethods__["seqNum"] = _mmut.HetRec_seqNum_set
    __swig_getmethods__["seqNum"] = _mmut.HetRec_seqNum_get
    if _newclass:seqNum = _swig_property(_mmut.HetRec_seqNum_get, _mmut.HetRec_seqNum_set)
    __swig_setmethods__["insCode"] = _mmut.HetRec_insCode_set
    __swig_getmethods__["insCode"] = _mmut.HetRec_insCode_get
    if _newclass:insCode = _swig_property(_mmut.HetRec_insCode_get, _mmut.HetRec_insCode_set)
    __swig_setmethods__["numHetAtoms"] = _mmut.HetRec_numHetAtoms_set
    __swig_getmethods__["numHetAtoms"] = _mmut.HetRec_numHetAtoms_get
    if _newclass:numHetAtoms = _swig_property(_mmut.HetRec_numHetAtoms_get, _mmut.HetRec_numHetAtoms_set)
    __swig_setmethods__["comment"] = _mmut.HetRec_comment_set
    __swig_getmethods__["comment"] = _mmut.HetRec_comment_get
    if _newclass:comment = _swig_property(_mmut.HetRec_comment_get, _mmut.HetRec_comment_set)
    def __init__(self, *args): 
        this = _mmut.new_HetRec(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_HetRec
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.HetRec_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.HetRec_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.HetRec_GetCIF(self, *args)
    def GetClassID(self): return _mmut.HetRec_GetClassID(self)
    def Copy(self, *args): return _mmut.HetRec_Copy(self, *args)
HetRec_swigregister = _mmut.HetRec_swigregister
HetRec_swigregister(HetRec)


def newChain():
  return _mmut.newChain()
newChain = _mmut.newChain

def SetMakersChain(*args):
  return _mmut.SetMakersChain(*args)
SetMakersChain = _mmut.SetMakersChain
class Chain(UDData):
    __swig_setmethods__ = {}
    for _s in [UDData]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chain, name, value)
    __swig_getmethods__ = {}
    for _s in [UDData]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Chain, name)
    __repr__ = _swig_repr
    __swig_setmethods__["DBRef"] = _mmut.Chain_DBRef_set
    __swig_getmethods__["DBRef"] = _mmut.Chain_DBRef_get
    if _newclass:DBRef = _swig_property(_mmut.Chain_DBRef_get, _mmut.Chain_DBRef_set)
    __swig_setmethods__["seqAdv"] = _mmut.Chain_seqAdv_set
    __swig_getmethods__["seqAdv"] = _mmut.Chain_seqAdv_get
    if _newclass:seqAdv = _swig_property(_mmut.Chain_seqAdv_get, _mmut.Chain_seqAdv_set)
    __swig_setmethods__["seqRes"] = _mmut.Chain_seqRes_set
    __swig_getmethods__["seqRes"] = _mmut.Chain_seqRes_get
    if _newclass:seqRes = _swig_property(_mmut.Chain_seqRes_get, _mmut.Chain_seqRes_set)
    __swig_setmethods__["modRes"] = _mmut.Chain_modRes_set
    __swig_getmethods__["modRes"] = _mmut.Chain_modRes_get
    if _newclass:modRes = _swig_property(_mmut.Chain_modRes_get, _mmut.Chain_modRes_set)
    __swig_setmethods__["Het"] = _mmut.Chain_Het_set
    __swig_getmethods__["Het"] = _mmut.Chain_Het_get
    if _newclass:Het = _swig_property(_mmut.Chain_Het_get, _mmut.Chain_Het_set)
    def __init__(self, *args): 
        this = _mmut.new_Chain(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Chain
    __del__ = lambda self : None;
    def FreeAnnotations(self): return _mmut.Chain_FreeAnnotations(self)
    def SetModel(self, *args): return _mmut.Chain_SetModel(self, *args)
    def SetChain(self, *args): return _mmut.Chain_SetChain(self, *args)
    def GetCoordHierarchy(self): return _mmut.Chain_GetCoordHierarchy(self)
    def ConvertDBREF(self, *args): return _mmut.Chain_ConvertDBREF(self, *args)
    def ConvertSEQADV(self, *args): return _mmut.Chain_ConvertSEQADV(self, *args)
    def ConvertSEQRES(self, *args): return _mmut.Chain_ConvertSEQRES(self, *args)
    def ConvertMODRES(self, *args): return _mmut.Chain_ConvertMODRES(self, *args)
    def ConvertHET(self, *args): return _mmut.Chain_ConvertHET(self, *args)
    def MakeAtomCIF(self, *args): return _mmut.Chain_MakeAtomCIF(self, *args)
    def GetNumberOfResidues(self): return _mmut.Chain_GetNumberOfResidues(self)
    def GetResidue(self, *args): return _mmut.Chain_GetResidue(self, *args)
    def GetResidueNo(self, *args): return _mmut.Chain_GetResidueNo(self, *args)
    def GetResidueTable(self, *args): return _mmut.Chain_GetResidueTable(self, *args)
    def GetResidueCreate(self, *args): return _mmut.Chain_GetResidueCreate(self, *args)
    def DeleteResidue(self, *args): return _mmut.Chain_DeleteResidue(self, *args)
    def DeleteAllResidues(self): return _mmut.Chain_DeleteAllResidues(self)
    def DeleteSolvent(self): return _mmut.Chain_DeleteSolvent(self)
    def TrimResidueTable(self): return _mmut.Chain_TrimResidueTable(self)
    def AddResidue(self, *args): return _mmut.Chain_AddResidue(self, *args)
    def InsResidue(self, *args): return _mmut.Chain_InsResidue(self, *args)
    def GetNumberOfAtoms(self, *args): return _mmut.Chain_GetNumberOfAtoms(self, *args)
    def GetAtom(self, *args): return _mmut.Chain_GetAtom(self, *args)
    def GetAtomTable(self, *args): return _mmut.Chain_GetAtomTable(self, *args)
    def GetAtomTable1(self, *args): return _mmut.Chain_GetAtomTable1(self, *args)
    def DeleteAtom(self, *args): return _mmut.Chain_DeleteAtom(self, *args)
    def DeleteAllAtoms(self, *args): return _mmut.Chain_DeleteAllAtoms(self, *args)
    def DeleteAltLocs(self): return _mmut.Chain_DeleteAltLocs(self)
    def AddAtom(self, *args): return _mmut.Chain_AddAtom(self, *args)
    def ApplyTransform(self, *args): return _mmut.Chain_ApplyTransform(self, *args)
    def GetModelNum(self): return _mmut.Chain_GetModelNum(self)
    def GetModel(self): return _mmut.Chain_GetModel(self)
    def SetChainID(self, *args): return _mmut.Chain_SetChainID(self, *args)
    def GetChainID(self, *args): return _mmut.Chain_GetChainID(self, *args)
    def CheckID(self, *args): return _mmut.Chain_CheckID(self, *args)
    def CheckIDS(self, *args): return _mmut.Chain_CheckIDS(self, *args)
    def GetEntryID(self): return _mmut.Chain_GetEntryID(self)
    def SetEntryID(self, *args): return _mmut.Chain_SetEntryID(self, *args)
    def GetNumberOfDBRefs(self): return _mmut.Chain_GetNumberOfDBRefs(self)
    def GetDBRef(self, *args): return _mmut.Chain_GetDBRef(self, *args)
    def MaskAtoms(self, *args): return _mmut.Chain_MaskAtoms(self, *args)
    def MaskResidues(self, *args): return _mmut.Chain_MaskResidues(self, *args)
    def UnmaskAtoms(self, *args): return _mmut.Chain_UnmaskAtoms(self, *args)
    def UnmaskResidues(self, *args): return _mmut.Chain_UnmaskResidues(self, *args)
    def SortResidues(self): return _mmut.Chain_SortResidues(self)
    def GetNofModResidues(self): return _mmut.Chain_GetNofModResidues(self)
    def GetModResidue(self, *args): return _mmut.Chain_GetModResidue(self, *args)
    def isSolventChain(self): return _mmut.Chain_isSolventChain(self)
    def isInSelection(self, *args): return _mmut.Chain_isInSelection(self, *args)
    def isAminoacidChain(self): return _mmut.Chain_isAminoacidChain(self)
    def isNucleotideChain(self): return _mmut.Chain_isNucleotideChain(self)
    def PutUDData(self, *args): return _mmut.Chain_PutUDData(self, *args)
    def GetUDData(self, *args): return _mmut.Chain_GetUDData(self, *args)
    def Copy(self, *args): return _mmut.Chain_Copy(self, *args)
    def CopyAnnotations(self, *args): return _mmut.Chain_CopyAnnotations(self, *args)
Chain_swigregister = _mmut.Chain_swigregister
Chain_swigregister(Chain)

ASET_Coordinates = _mmut.ASET_Coordinates
ASET_Occupancy = _mmut.ASET_Occupancy
ASET_tempFactor = _mmut.ASET_tempFactor
ASET_CoordSigma = _mmut.ASET_CoordSigma
ASET_OccSigma = _mmut.ASET_OccSigma
ASET_tFacSigma = _mmut.ASET_tFacSigma
ASET_Anis_tFac = _mmut.ASET_Anis_tFac
ASET_Anis_tFSigma = _mmut.ASET_Anis_tFSigma
ASET_Charge = _mmut.ASET_Charge
ASET_All = _mmut.ASET_All
class AtomStat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomStat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomStat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nAtoms"] = _mmut.AtomStat_nAtoms_set
    __swig_getmethods__["nAtoms"] = _mmut.AtomStat_nAtoms_get
    if _newclass:nAtoms = _swig_property(_mmut.AtomStat_nAtoms_get, _mmut.AtomStat_nAtoms_set)
    __swig_setmethods__["xmin"] = _mmut.AtomStat_xmin_set
    __swig_getmethods__["xmin"] = _mmut.AtomStat_xmin_get
    if _newclass:xmin = _swig_property(_mmut.AtomStat_xmin_get, _mmut.AtomStat_xmin_set)
    __swig_setmethods__["ymin"] = _mmut.AtomStat_ymin_set
    __swig_getmethods__["ymin"] = _mmut.AtomStat_ymin_get
    if _newclass:ymin = _swig_property(_mmut.AtomStat_ymin_get, _mmut.AtomStat_ymin_set)
    __swig_setmethods__["zmin"] = _mmut.AtomStat_zmin_set
    __swig_getmethods__["zmin"] = _mmut.AtomStat_zmin_get
    if _newclass:zmin = _swig_property(_mmut.AtomStat_zmin_get, _mmut.AtomStat_zmin_set)
    __swig_setmethods__["xmax"] = _mmut.AtomStat_xmax_set
    __swig_getmethods__["xmax"] = _mmut.AtomStat_xmax_get
    if _newclass:xmax = _swig_property(_mmut.AtomStat_xmax_get, _mmut.AtomStat_xmax_set)
    __swig_setmethods__["ymax"] = _mmut.AtomStat_ymax_set
    __swig_getmethods__["ymax"] = _mmut.AtomStat_ymax_get
    if _newclass:ymax = _swig_property(_mmut.AtomStat_ymax_get, _mmut.AtomStat_ymax_set)
    __swig_setmethods__["zmax"] = _mmut.AtomStat_zmax_set
    __swig_getmethods__["zmax"] = _mmut.AtomStat_zmax_get
    if _newclass:zmax = _swig_property(_mmut.AtomStat_zmax_get, _mmut.AtomStat_zmax_set)
    __swig_setmethods__["xm"] = _mmut.AtomStat_xm_set
    __swig_getmethods__["xm"] = _mmut.AtomStat_xm_get
    if _newclass:xm = _swig_property(_mmut.AtomStat_xm_get, _mmut.AtomStat_xm_set)
    __swig_setmethods__["ym"] = _mmut.AtomStat_ym_set
    __swig_getmethods__["ym"] = _mmut.AtomStat_ym_get
    if _newclass:ym = _swig_property(_mmut.AtomStat_ym_get, _mmut.AtomStat_ym_set)
    __swig_setmethods__["zm"] = _mmut.AtomStat_zm_set
    __swig_getmethods__["zm"] = _mmut.AtomStat_zm_get
    if _newclass:zm = _swig_property(_mmut.AtomStat_zm_get, _mmut.AtomStat_zm_set)
    __swig_setmethods__["xm2"] = _mmut.AtomStat_xm2_set
    __swig_getmethods__["xm2"] = _mmut.AtomStat_xm2_get
    if _newclass:xm2 = _swig_property(_mmut.AtomStat_xm2_get, _mmut.AtomStat_xm2_set)
    __swig_setmethods__["ym2"] = _mmut.AtomStat_ym2_set
    __swig_getmethods__["ym2"] = _mmut.AtomStat_ym2_get
    if _newclass:ym2 = _swig_property(_mmut.AtomStat_ym2_get, _mmut.AtomStat_ym2_set)
    __swig_setmethods__["zm2"] = _mmut.AtomStat_zm2_set
    __swig_getmethods__["zm2"] = _mmut.AtomStat_zm2_get
    if _newclass:zm2 = _swig_property(_mmut.AtomStat_zm2_get, _mmut.AtomStat_zm2_set)
    __swig_setmethods__["occ_min"] = _mmut.AtomStat_occ_min_set
    __swig_getmethods__["occ_min"] = _mmut.AtomStat_occ_min_get
    if _newclass:occ_min = _swig_property(_mmut.AtomStat_occ_min_get, _mmut.AtomStat_occ_min_set)
    __swig_setmethods__["occ_max"] = _mmut.AtomStat_occ_max_set
    __swig_getmethods__["occ_max"] = _mmut.AtomStat_occ_max_get
    if _newclass:occ_max = _swig_property(_mmut.AtomStat_occ_max_get, _mmut.AtomStat_occ_max_set)
    __swig_setmethods__["occ_m"] = _mmut.AtomStat_occ_m_set
    __swig_getmethods__["occ_m"] = _mmut.AtomStat_occ_m_get
    if _newclass:occ_m = _swig_property(_mmut.AtomStat_occ_m_get, _mmut.AtomStat_occ_m_set)
    __swig_setmethods__["occ_m2"] = _mmut.AtomStat_occ_m2_set
    __swig_getmethods__["occ_m2"] = _mmut.AtomStat_occ_m2_get
    if _newclass:occ_m2 = _swig_property(_mmut.AtomStat_occ_m2_get, _mmut.AtomStat_occ_m2_set)
    __swig_setmethods__["tFmin"] = _mmut.AtomStat_tFmin_set
    __swig_getmethods__["tFmin"] = _mmut.AtomStat_tFmin_get
    if _newclass:tFmin = _swig_property(_mmut.AtomStat_tFmin_get, _mmut.AtomStat_tFmin_set)
    __swig_setmethods__["tFmax"] = _mmut.AtomStat_tFmax_set
    __swig_getmethods__["tFmax"] = _mmut.AtomStat_tFmax_get
    if _newclass:tFmax = _swig_property(_mmut.AtomStat_tFmax_get, _mmut.AtomStat_tFmax_set)
    __swig_setmethods__["tFm"] = _mmut.AtomStat_tFm_set
    __swig_getmethods__["tFm"] = _mmut.AtomStat_tFm_get
    if _newclass:tFm = _swig_property(_mmut.AtomStat_tFm_get, _mmut.AtomStat_tFm_set)
    __swig_setmethods__["tFm2"] = _mmut.AtomStat_tFm2_set
    __swig_getmethods__["tFm2"] = _mmut.AtomStat_tFm2_get
    if _newclass:tFm2 = _swig_property(_mmut.AtomStat_tFm2_get, _mmut.AtomStat_tFm2_set)
    __swig_setmethods__["u11_min"] = _mmut.AtomStat_u11_min_set
    __swig_getmethods__["u11_min"] = _mmut.AtomStat_u11_min_get
    if _newclass:u11_min = _swig_property(_mmut.AtomStat_u11_min_get, _mmut.AtomStat_u11_min_set)
    __swig_setmethods__["u11_max"] = _mmut.AtomStat_u11_max_set
    __swig_getmethods__["u11_max"] = _mmut.AtomStat_u11_max_get
    if _newclass:u11_max = _swig_property(_mmut.AtomStat_u11_max_get, _mmut.AtomStat_u11_max_set)
    __swig_setmethods__["u22_min"] = _mmut.AtomStat_u22_min_set
    __swig_getmethods__["u22_min"] = _mmut.AtomStat_u22_min_get
    if _newclass:u22_min = _swig_property(_mmut.AtomStat_u22_min_get, _mmut.AtomStat_u22_min_set)
    __swig_setmethods__["u22_max"] = _mmut.AtomStat_u22_max_set
    __swig_getmethods__["u22_max"] = _mmut.AtomStat_u22_max_get
    if _newclass:u22_max = _swig_property(_mmut.AtomStat_u22_max_get, _mmut.AtomStat_u22_max_set)
    __swig_setmethods__["u33_min"] = _mmut.AtomStat_u33_min_set
    __swig_getmethods__["u33_min"] = _mmut.AtomStat_u33_min_get
    if _newclass:u33_min = _swig_property(_mmut.AtomStat_u33_min_get, _mmut.AtomStat_u33_min_set)
    __swig_setmethods__["u33_max"] = _mmut.AtomStat_u33_max_set
    __swig_getmethods__["u33_max"] = _mmut.AtomStat_u33_max_get
    if _newclass:u33_max = _swig_property(_mmut.AtomStat_u33_max_get, _mmut.AtomStat_u33_max_set)
    __swig_setmethods__["u12_min"] = _mmut.AtomStat_u12_min_set
    __swig_getmethods__["u12_min"] = _mmut.AtomStat_u12_min_get
    if _newclass:u12_min = _swig_property(_mmut.AtomStat_u12_min_get, _mmut.AtomStat_u12_min_set)
    __swig_setmethods__["u12_max"] = _mmut.AtomStat_u12_max_set
    __swig_getmethods__["u12_max"] = _mmut.AtomStat_u12_max_get
    if _newclass:u12_max = _swig_property(_mmut.AtomStat_u12_max_get, _mmut.AtomStat_u12_max_set)
    __swig_setmethods__["u13_min"] = _mmut.AtomStat_u13_min_set
    __swig_getmethods__["u13_min"] = _mmut.AtomStat_u13_min_get
    if _newclass:u13_min = _swig_property(_mmut.AtomStat_u13_min_get, _mmut.AtomStat_u13_min_set)
    __swig_setmethods__["u13_max"] = _mmut.AtomStat_u13_max_set
    __swig_getmethods__["u13_max"] = _mmut.AtomStat_u13_max_get
    if _newclass:u13_max = _swig_property(_mmut.AtomStat_u13_max_get, _mmut.AtomStat_u13_max_set)
    __swig_setmethods__["u23_min"] = _mmut.AtomStat_u23_min_set
    __swig_getmethods__["u23_min"] = _mmut.AtomStat_u23_min_get
    if _newclass:u23_min = _swig_property(_mmut.AtomStat_u23_min_get, _mmut.AtomStat_u23_min_set)
    __swig_setmethods__["u23_max"] = _mmut.AtomStat_u23_max_set
    __swig_getmethods__["u23_max"] = _mmut.AtomStat_u23_max_get
    if _newclass:u23_max = _swig_property(_mmut.AtomStat_u23_max_get, _mmut.AtomStat_u23_max_set)
    __swig_setmethods__["u11_m"] = _mmut.AtomStat_u11_m_set
    __swig_getmethods__["u11_m"] = _mmut.AtomStat_u11_m_get
    if _newclass:u11_m = _swig_property(_mmut.AtomStat_u11_m_get, _mmut.AtomStat_u11_m_set)
    __swig_setmethods__["u11_m2"] = _mmut.AtomStat_u11_m2_set
    __swig_getmethods__["u11_m2"] = _mmut.AtomStat_u11_m2_get
    if _newclass:u11_m2 = _swig_property(_mmut.AtomStat_u11_m2_get, _mmut.AtomStat_u11_m2_set)
    __swig_setmethods__["u22_m"] = _mmut.AtomStat_u22_m_set
    __swig_getmethods__["u22_m"] = _mmut.AtomStat_u22_m_get
    if _newclass:u22_m = _swig_property(_mmut.AtomStat_u22_m_get, _mmut.AtomStat_u22_m_set)
    __swig_setmethods__["u22_m2"] = _mmut.AtomStat_u22_m2_set
    __swig_getmethods__["u22_m2"] = _mmut.AtomStat_u22_m2_get
    if _newclass:u22_m2 = _swig_property(_mmut.AtomStat_u22_m2_get, _mmut.AtomStat_u22_m2_set)
    __swig_setmethods__["u33_m"] = _mmut.AtomStat_u33_m_set
    __swig_getmethods__["u33_m"] = _mmut.AtomStat_u33_m_get
    if _newclass:u33_m = _swig_property(_mmut.AtomStat_u33_m_get, _mmut.AtomStat_u33_m_set)
    __swig_setmethods__["u33_m2"] = _mmut.AtomStat_u33_m2_set
    __swig_getmethods__["u33_m2"] = _mmut.AtomStat_u33_m2_get
    if _newclass:u33_m2 = _swig_property(_mmut.AtomStat_u33_m2_get, _mmut.AtomStat_u33_m2_set)
    __swig_setmethods__["u12_m"] = _mmut.AtomStat_u12_m_set
    __swig_getmethods__["u12_m"] = _mmut.AtomStat_u12_m_get
    if _newclass:u12_m = _swig_property(_mmut.AtomStat_u12_m_get, _mmut.AtomStat_u12_m_set)
    __swig_setmethods__["u12_m2"] = _mmut.AtomStat_u12_m2_set
    __swig_getmethods__["u12_m2"] = _mmut.AtomStat_u12_m2_get
    if _newclass:u12_m2 = _swig_property(_mmut.AtomStat_u12_m2_get, _mmut.AtomStat_u12_m2_set)
    __swig_setmethods__["u13_m"] = _mmut.AtomStat_u13_m_set
    __swig_getmethods__["u13_m"] = _mmut.AtomStat_u13_m_get
    if _newclass:u13_m = _swig_property(_mmut.AtomStat_u13_m_get, _mmut.AtomStat_u13_m_set)
    __swig_setmethods__["u13_m2"] = _mmut.AtomStat_u13_m2_set
    __swig_getmethods__["u13_m2"] = _mmut.AtomStat_u13_m2_get
    if _newclass:u13_m2 = _swig_property(_mmut.AtomStat_u13_m2_get, _mmut.AtomStat_u13_m2_set)
    __swig_setmethods__["u23_m"] = _mmut.AtomStat_u23_m_set
    __swig_getmethods__["u23_m"] = _mmut.AtomStat_u23_m_get
    if _newclass:u23_m = _swig_property(_mmut.AtomStat_u23_m_get, _mmut.AtomStat_u23_m_set)
    __swig_setmethods__["u23_m2"] = _mmut.AtomStat_u23_m2_set
    __swig_getmethods__["u23_m2"] = _mmut.AtomStat_u23_m2_get
    if _newclass:u23_m2 = _swig_property(_mmut.AtomStat_u23_m2_get, _mmut.AtomStat_u23_m2_set)
    __swig_setmethods__["WhatIsSet"] = _mmut.AtomStat_WhatIsSet_set
    __swig_getmethods__["WhatIsSet"] = _mmut.AtomStat_WhatIsSet_get
    if _newclass:WhatIsSet = _swig_property(_mmut.AtomStat_WhatIsSet_get, _mmut.AtomStat_WhatIsSet_set)
    def Init(self): return _mmut.AtomStat_Init(self)
    def Finish(self): return _mmut.AtomStat_Finish(self)
    def GetMaxSize(self): return _mmut.AtomStat_GetMaxSize(self)
    def __init__(self): 
        this = _mmut.new_AtomStat()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_AtomStat
    __del__ = lambda self : None;
AtomStat_swigregister = _mmut.AtomStat_swigregister
AtomStat_swigregister(AtomStat)
ATOM_NoSeqNum = cvar.ATOM_NoSeqNum

class AtomBondI(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomBondI, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomBondI, name)
    __repr__ = _swig_repr
    __swig_setmethods__["index"] = _mmut.AtomBondI_index_set
    __swig_getmethods__["index"] = _mmut.AtomBondI_index_get
    if _newclass:index = _swig_property(_mmut.AtomBondI_index_get, _mmut.AtomBondI_index_set)
    __swig_setmethods__["order"] = _mmut.AtomBondI_order_set
    __swig_getmethods__["order"] = _mmut.AtomBondI_order_get
    if _newclass:order = _swig_property(_mmut.AtomBondI_order_get, _mmut.AtomBondI_order_set)
    def __init__(self): 
        this = _mmut.new_AtomBondI()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_AtomBondI
    __del__ = lambda self : None;
AtomBondI_swigregister = _mmut.AtomBondI_swigregister
AtomBondI_swigregister(AtomBondI)

class AtomBond(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomBond, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomBond, name)
    __repr__ = _swig_repr
    __swig_setmethods__["atom"] = _mmut.AtomBond_atom_set
    __swig_getmethods__["atom"] = _mmut.AtomBond_atom_get
    if _newclass:atom = _swig_property(_mmut.AtomBond_atom_get, _mmut.AtomBond_atom_set)
    __swig_setmethods__["order"] = _mmut.AtomBond_order_set
    __swig_getmethods__["order"] = _mmut.AtomBond_order_get
    if _newclass:order = _swig_property(_mmut.AtomBond_order_get, _mmut.AtomBond_order_set)
    def __init__(self): 
        this = _mmut.new_AtomBond()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_AtomBond
    __del__ = lambda self : None;
AtomBond_swigregister = _mmut.AtomBond_swigregister
AtomBond_swigregister(AtomBond)


def newAtom():
  return _mmut.newAtom()
newAtom = _mmut.newAtom

def SetMakersAtom(*args):
  return _mmut.SetMakersAtom(*args)
SetMakersAtom = _mmut.SetMakersAtom
class Atom(UDData):
    __swig_setmethods__ = {}
    for _s in [UDData]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atom, name, value)
    __swig_getmethods__ = {}
    for _s in [UDData]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Atom, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serNum"] = _mmut.Atom_serNum_set
    __swig_getmethods__["serNum"] = _mmut.Atom_serNum_get
    if _newclass:serNum = _swig_property(_mmut.Atom_serNum_get, _mmut.Atom_serNum_set)
    __swig_setmethods__["name"] = _mmut.Atom_name_set
    __swig_getmethods__["name"] = _mmut.Atom_name_get
    if _newclass:name = _swig_property(_mmut.Atom_name_get, _mmut.Atom_name_set)
    __swig_setmethods__["altLoc"] = _mmut.Atom_altLoc_set
    __swig_getmethods__["altLoc"] = _mmut.Atom_altLoc_get
    if _newclass:altLoc = _swig_property(_mmut.Atom_altLoc_get, _mmut.Atom_altLoc_set)
    __swig_setmethods__["segID"] = _mmut.Atom_segID_set
    __swig_getmethods__["segID"] = _mmut.Atom_segID_get
    if _newclass:segID = _swig_property(_mmut.Atom_segID_get, _mmut.Atom_segID_set)
    __swig_setmethods__["element"] = _mmut.Atom_element_set
    __swig_getmethods__["element"] = _mmut.Atom_element_get
    if _newclass:element = _swig_property(_mmut.Atom_element_get, _mmut.Atom_element_set)
    __swig_setmethods__["energyType"] = _mmut.Atom_energyType_set
    __swig_getmethods__["energyType"] = _mmut.Atom_energyType_get
    if _newclass:energyType = _swig_property(_mmut.Atom_energyType_get, _mmut.Atom_energyType_set)
    __swig_setmethods__["residue"] = _mmut.Atom_residue_set
    __swig_getmethods__["residue"] = _mmut.Atom_residue_get
    if _newclass:residue = _swig_property(_mmut.Atom_residue_get, _mmut.Atom_residue_set)
    __swig_setmethods__["x"] = _mmut.Atom_x_set
    __swig_getmethods__["x"] = _mmut.Atom_x_get
    if _newclass:x = _swig_property(_mmut.Atom_x_get, _mmut.Atom_x_set)
    __swig_setmethods__["y"] = _mmut.Atom_y_set
    __swig_getmethods__["y"] = _mmut.Atom_y_get
    if _newclass:y = _swig_property(_mmut.Atom_y_get, _mmut.Atom_y_set)
    __swig_setmethods__["z"] = _mmut.Atom_z_set
    __swig_getmethods__["z"] = _mmut.Atom_z_get
    if _newclass:z = _swig_property(_mmut.Atom_z_get, _mmut.Atom_z_set)
    __swig_setmethods__["occupancy"] = _mmut.Atom_occupancy_set
    __swig_getmethods__["occupancy"] = _mmut.Atom_occupancy_get
    if _newclass:occupancy = _swig_property(_mmut.Atom_occupancy_get, _mmut.Atom_occupancy_set)
    __swig_setmethods__["tempFactor"] = _mmut.Atom_tempFactor_set
    __swig_getmethods__["tempFactor"] = _mmut.Atom_tempFactor_get
    if _newclass:tempFactor = _swig_property(_mmut.Atom_tempFactor_get, _mmut.Atom_tempFactor_set)
    __swig_setmethods__["charge"] = _mmut.Atom_charge_set
    __swig_getmethods__["charge"] = _mmut.Atom_charge_get
    if _newclass:charge = _swig_property(_mmut.Atom_charge_get, _mmut.Atom_charge_set)
    __swig_setmethods__["sigX"] = _mmut.Atom_sigX_set
    __swig_getmethods__["sigX"] = _mmut.Atom_sigX_get
    if _newclass:sigX = _swig_property(_mmut.Atom_sigX_get, _mmut.Atom_sigX_set)
    __swig_setmethods__["sigY"] = _mmut.Atom_sigY_set
    __swig_getmethods__["sigY"] = _mmut.Atom_sigY_get
    if _newclass:sigY = _swig_property(_mmut.Atom_sigY_get, _mmut.Atom_sigY_set)
    __swig_setmethods__["sigZ"] = _mmut.Atom_sigZ_set
    __swig_getmethods__["sigZ"] = _mmut.Atom_sigZ_get
    if _newclass:sigZ = _swig_property(_mmut.Atom_sigZ_get, _mmut.Atom_sigZ_set)
    __swig_setmethods__["sigOcc"] = _mmut.Atom_sigOcc_set
    __swig_getmethods__["sigOcc"] = _mmut.Atom_sigOcc_get
    if _newclass:sigOcc = _swig_property(_mmut.Atom_sigOcc_get, _mmut.Atom_sigOcc_set)
    __swig_setmethods__["sigTemp"] = _mmut.Atom_sigTemp_set
    __swig_getmethods__["sigTemp"] = _mmut.Atom_sigTemp_get
    if _newclass:sigTemp = _swig_property(_mmut.Atom_sigTemp_get, _mmut.Atom_sigTemp_set)
    __swig_setmethods__["u11"] = _mmut.Atom_u11_set
    __swig_getmethods__["u11"] = _mmut.Atom_u11_get
    if _newclass:u11 = _swig_property(_mmut.Atom_u11_get, _mmut.Atom_u11_set)
    __swig_setmethods__["u22"] = _mmut.Atom_u22_set
    __swig_getmethods__["u22"] = _mmut.Atom_u22_get
    if _newclass:u22 = _swig_property(_mmut.Atom_u22_get, _mmut.Atom_u22_set)
    __swig_setmethods__["u33"] = _mmut.Atom_u33_set
    __swig_getmethods__["u33"] = _mmut.Atom_u33_get
    if _newclass:u33 = _swig_property(_mmut.Atom_u33_get, _mmut.Atom_u33_set)
    __swig_setmethods__["u12"] = _mmut.Atom_u12_set
    __swig_getmethods__["u12"] = _mmut.Atom_u12_get
    if _newclass:u12 = _swig_property(_mmut.Atom_u12_get, _mmut.Atom_u12_set)
    __swig_setmethods__["u13"] = _mmut.Atom_u13_set
    __swig_getmethods__["u13"] = _mmut.Atom_u13_get
    if _newclass:u13 = _swig_property(_mmut.Atom_u13_get, _mmut.Atom_u13_set)
    __swig_setmethods__["u23"] = _mmut.Atom_u23_set
    __swig_getmethods__["u23"] = _mmut.Atom_u23_get
    if _newclass:u23 = _swig_property(_mmut.Atom_u23_get, _mmut.Atom_u23_set)
    __swig_setmethods__["su11"] = _mmut.Atom_su11_set
    __swig_getmethods__["su11"] = _mmut.Atom_su11_get
    if _newclass:su11 = _swig_property(_mmut.Atom_su11_get, _mmut.Atom_su11_set)
    __swig_setmethods__["su22"] = _mmut.Atom_su22_set
    __swig_getmethods__["su22"] = _mmut.Atom_su22_get
    if _newclass:su22 = _swig_property(_mmut.Atom_su22_get, _mmut.Atom_su22_set)
    __swig_setmethods__["su33"] = _mmut.Atom_su33_set
    __swig_getmethods__["su33"] = _mmut.Atom_su33_get
    if _newclass:su33 = _swig_property(_mmut.Atom_su33_get, _mmut.Atom_su33_set)
    __swig_setmethods__["su12"] = _mmut.Atom_su12_set
    __swig_getmethods__["su12"] = _mmut.Atom_su12_get
    if _newclass:su12 = _swig_property(_mmut.Atom_su12_get, _mmut.Atom_su12_set)
    __swig_setmethods__["su13"] = _mmut.Atom_su13_set
    __swig_getmethods__["su13"] = _mmut.Atom_su13_get
    if _newclass:su13 = _swig_property(_mmut.Atom_su13_get, _mmut.Atom_su13_set)
    __swig_setmethods__["su23"] = _mmut.Atom_su23_set
    __swig_getmethods__["su23"] = _mmut.Atom_su23_get
    if _newclass:su23 = _swig_property(_mmut.Atom_su23_get, _mmut.Atom_su23_set)
    __swig_setmethods__["Het"] = _mmut.Atom_Het_set
    __swig_getmethods__["Het"] = _mmut.Atom_Het_get
    if _newclass:Het = _swig_property(_mmut.Atom_Het_get, _mmut.Atom_Het_set)
    __swig_setmethods__["Ter"] = _mmut.Atom_Ter_set
    __swig_getmethods__["Ter"] = _mmut.Atom_Ter_get
    if _newclass:Ter = _swig_property(_mmut.Atom_Ter_get, _mmut.Atom_Ter_set)
    __swig_setmethods__["WhatIsSet"] = _mmut.Atom_WhatIsSet_set
    __swig_getmethods__["WhatIsSet"] = _mmut.Atom_WhatIsSet_get
    if _newclass:WhatIsSet = _swig_property(_mmut.Atom_WhatIsSet_get, _mmut.Atom_WhatIsSet_set)
    def __init__(self, *args): 
        this = _mmut.new_Atom(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Atom
    __del__ = lambda self : None;
    def SetResidue(self, *args): return _mmut.Atom_SetResidue(self, *args)
    def MakeCIF(self, *args): return _mmut.Atom_MakeCIF(self, *args)
    def AddBond(self, *args): return _mmut.Atom_AddBond(self, *args)
    def GetNBonds(self): return _mmut.Atom_GetNBonds(self)
    def FreeBonds(self): return _mmut.Atom_FreeBonds(self)
    def ConvertPDBATOM(self, *args): return _mmut.Atom_ConvertPDBATOM(self, *args)
    def ConvertPDBSIGATM(self, *args): return _mmut.Atom_ConvertPDBSIGATM(self, *args)
    def ConvertPDBANISOU(self, *args): return _mmut.Atom_ConvertPDBANISOU(self, *args)
    def ConvertPDBSIGUIJ(self, *args): return _mmut.Atom_ConvertPDBSIGUIJ(self, *args)
    def ConvertPDBTER(self, *args): return _mmut.Atom_ConvertPDBTER(self, *args)
    def ConvertPDBHETATM(self, *args): return _mmut.Atom_ConvertPDBHETATM(self, *args)
    def GetCIF(self, *args): return _mmut.Atom_GetCIF(self, *args)
    def RestoreElementName(self): return _mmut.Atom_RestoreElementName(self)
    def MakePDBAtomName(self): return _mmut.Atom_MakePDBAtomName(self)
    def SetAtomName(self, *args): return _mmut.Atom_SetAtomName(self, *args)
    def SetElementName(self, *args): return _mmut.Atom_SetElementName(self, *args)
    def SetCharge(self, *args): return _mmut.Atom_SetCharge(self, *args)
    def SetAtomIndex(self, *args): return _mmut.Atom_SetAtomIndex(self, *args)
    def MakeTer(self): return _mmut.Atom_MakeTer(self)
    def SetCoordinates(self, *args): return _mmut.Atom_SetCoordinates(self, *args)
    def GetModelNum(self): return _mmut.Atom_GetModelNum(self)
    def GetChainID(self): return _mmut.Atom_GetChainID(self)
    def GetResName(self): return _mmut.Atom_GetResName(self)
    def GetAASimilarity(self, *args): return _mmut.Atom_GetAASimilarity(self, *args)
    def GetAAHydropathy(self): return _mmut.Atom_GetAAHydropathy(self)
    def GetOccupancy(self): return _mmut.Atom_GetOccupancy(self)
    def GetSeqNum(self): return _mmut.Atom_GetSeqNum(self)
    def GetInsCode(self): return _mmut.Atom_GetInsCode(self)
    def GetSSEType(self): return _mmut.Atom_GetSSEType(self)
    def GetAtomName(self): return _mmut.Atom_GetAtomName(self)
    def GetElementName(self): return _mmut.Atom_GetElementName(self)
    def GetAtomCharge(self, *args): return _mmut.Atom_GetAtomCharge(self, *args)
    def GetChainCalphas(self, *args): return _mmut.Atom_GetChainCalphas(self, *args)
    def isTer(self): return _mmut.Atom_isTer(self)
    def isMetal(self): return _mmut.Atom_isMetal(self)
    def isSolvent(self): return _mmut.Atom_isSolvent(self)
    def isInSelection(self, *args): return _mmut.Atom_isInSelection(self, *args)
    def isNTerminus(self): return _mmut.Atom_isNTerminus(self)
    def isCTerminus(self): return _mmut.Atom_isCTerminus(self)
    def GetDist2(self, *args): return _mmut.Atom_GetDist2(self, *args)
    def GetCosine(self, *args): return _mmut.Atom_GetCosine(self, *args)
    def GetResidue(self): return _mmut.Atom_GetResidue(self)
    def GetChain(self): return _mmut.Atom_GetChain(self)
    def GetModel(self): return _mmut.Atom_GetModel(self)
    def GetResidueNo(self): return _mmut.Atom_GetResidueNo(self)
    def GetCoordHierarchy(self): return _mmut.Atom_GetCoordHierarchy(self)
    def GetAtomID(self): return _mmut.Atom_GetAtomID(self)
    def GetAtomIDfmt(self): return _mmut.Atom_GetAtomIDfmt(self)
    def CheckID(self, *args): return _mmut.Atom_CheckID(self, *args)
    def CheckIDS(self, *args): return _mmut.Atom_CheckIDS(self, *args)
    def Transform(self, *args): return _mmut.Atom_Transform(self, *args)
    def TransformCopy(self, *args): return _mmut.Atom_TransformCopy(self, *args)
    def TransformSet(self, *args): return _mmut.Atom_TransformSet(self, *args)
    def PutUDData(self, *args): return _mmut.Atom_PutUDData(self, *args)
    def GetUDData(self, *args): return _mmut.Atom_GetUDData(self, *args)
    def GetIndex(self): return _mmut.Atom_GetIndex(self)
    def Copy(self, *args): return _mmut.Atom_Copy(self, *args)
    def SetShortBinary(self): return _mmut.Atom_SetShortBinary(self)
    def GetAltLoc(self): return _mmut.Atom_GetAltLoc(self)
    def GetSegID(self): return _mmut.Atom_GetSegID(self)
Atom_swigregister = _mmut.Atom_swigregister
Atom_swigregister(Atom)

ALF_NoAltCodes = _mmut.ALF_NoAltCodes
ALF_EmptyAltLoc = _mmut.ALF_EmptyAltLoc
ALF_NoEmptyAltLoc = _mmut.ALF_NoEmptyAltLoc
ALF_Mess = _mmut.ALF_Mess
ALF_Occupancy = _mmut.ALF_Occupancy
SSE_None = _mmut.SSE_None
SSE_Strand = _mmut.SSE_Strand
SSE_Bulge = _mmut.SSE_Bulge
SSE_3Turn = _mmut.SSE_3Turn
SSE_4Turn = _mmut.SSE_4Turn
SSE_5Turn = _mmut.SSE_5Turn
SSE_Helix = _mmut.SSE_Helix

def newResidue():
  return _mmut.newResidue()
newResidue = _mmut.newResidue

def SetMakersResidue(*args):
  return _mmut.SetMakersResidue(*args)
SetMakersResidue = _mmut.SetMakersResidue
class Residue(UDData):
    __swig_setmethods__ = {}
    for _s in [UDData]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Residue, name, value)
    __swig_getmethods__ = {}
    for _s in [UDData]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Residue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _mmut.Residue_name_set
    __swig_getmethods__["name"] = _mmut.Residue_name_get
    if _newclass:name = _swig_property(_mmut.Residue_name_get, _mmut.Residue_name_set)
    __swig_setmethods__["insCode"] = _mmut.Residue_insCode_set
    __swig_getmethods__["insCode"] = _mmut.Residue_insCode_get
    if _newclass:insCode = _swig_property(_mmut.Residue_insCode_get, _mmut.Residue_insCode_set)
    __swig_setmethods__["chain"] = _mmut.Residue_chain_set
    __swig_getmethods__["chain"] = _mmut.Residue_chain_get
    if _newclass:chain = _swig_property(_mmut.Residue_chain_get, _mmut.Residue_chain_set)
    __swig_setmethods__["atom"] = _mmut.Residue_atom_set
    __swig_getmethods__["atom"] = _mmut.Residue_atom_get
    if _newclass:atom = _swig_property(_mmut.Residue_atom_get, _mmut.Residue_atom_set)
    __swig_setmethods__["seqNum"] = _mmut.Residue_seqNum_set
    __swig_getmethods__["seqNum"] = _mmut.Residue_seqNum_get
    if _newclass:seqNum = _swig_property(_mmut.Residue_seqNum_get, _mmut.Residue_seqNum_set)
    __swig_setmethods__["index"] = _mmut.Residue_index_set
    __swig_getmethods__["index"] = _mmut.Residue_index_get
    if _newclass:index = _swig_property(_mmut.Residue_index_get, _mmut.Residue_index_set)
    __swig_setmethods__["nAtoms"] = _mmut.Residue_nAtoms_set
    __swig_getmethods__["nAtoms"] = _mmut.Residue_nAtoms_get
    if _newclass:nAtoms = _swig_property(_mmut.Residue_nAtoms_get, _mmut.Residue_nAtoms_set)
    __swig_setmethods__["SSE"] = _mmut.Residue_SSE_set
    __swig_getmethods__["SSE"] = _mmut.Residue_SSE_get
    if _newclass:SSE = _swig_property(_mmut.Residue_SSE_get, _mmut.Residue_SSE_set)
    def __init__(self, *args): 
        this = _mmut.new_Residue(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Residue
    __del__ = lambda self : None;
    def SetChain(self, *args): return _mmut.Residue_SetChain(self, *args)
    def SetResID(self, *args): return _mmut.Residue_SetResID(self, *args)
    def SetChainID(self, *args): return _mmut.Residue_SetChainID(self, *args)
    def MakeAtomCIF(self, *args): return _mmut.Residue_MakeAtomCIF(self, *args)
    def GetChain(self): return _mmut.Residue_GetChain(self)
    def GetModel(self): return _mmut.Residue_GetModel(self)
    def GetModelNum(self): return _mmut.Residue_GetModelNum(self)
    def GetChainID(self): return _mmut.Residue_GetChainID(self)
    def GetResName(self): return _mmut.Residue_GetResName(self)
    def GetAASimilarity(self, *args): return _mmut.Residue_GetAASimilarity(self, *args)
    def GetAAHydropathy(self): return _mmut.Residue_GetAAHydropathy(self)
    def SetResName(self, *args): return _mmut.Residue_SetResName(self, *args)
    def GetSeqNum(self): return _mmut.Residue_GetSeqNum(self)
    def GetInsCode(self): return _mmut.Residue_GetInsCode(self)
    def GetResidueNo(self): return _mmut.Residue_GetResidueNo(self)
    def GetCenter(self, *args): return _mmut.Residue_GetCenter(self, *args)
    def GetCoordHierarchy(self): return _mmut.Residue_GetCoordHierarchy(self)
    def GetResidueID(self): return _mmut.Residue_GetResidueID(self)
    def GetAltLocations(self, *args): return _mmut.Residue_GetAltLocations(self, *args)
    def GetNofAltLocations(self): return _mmut.Residue_GetNofAltLocations(self)
    def isAminoacid(self): return _mmut.Residue_isAminoacid(self)
    def isNucleotide(self): return _mmut.Residue_isNucleotide(self)
    def isDNARNA(self): return _mmut.Residue_isDNARNA(self)
    def isSugar(self): return _mmut.Residue_isSugar(self)
    def isSolvent(self): return _mmut.Residue_isSolvent(self)
    def isModRes(self): return _mmut.Residue_isModRes(self)
    def isInSelection(self, *args): return _mmut.Residue_isInSelection(self, *args)
    def isNTerminus(self): return _mmut.Residue_isNTerminus(self)
    def isCTerminus(self): return _mmut.Residue_isCTerminus(self)
    def CheckID(self, *args): return _mmut.Residue_CheckID(self, *args)
    def CheckIDS(self, *args): return _mmut.Residue_CheckIDS(self, *args)
    def GetNumberOfAtoms(self, *args): return _mmut.Residue_GetNumberOfAtoms(self, *args)
    def GetAtom(self, *args): return _mmut.Residue_GetAtom(self, *args)
    def GetAtomTable(self, *args): return _mmut.Residue_GetAtomTable(self, *args)
    def GetAtomTable1(self, *args): return _mmut.Residue_GetAtomTable1(self, *args)
    def DeleteAtom(self, *args): return _mmut.Residue_DeleteAtom(self, *args)
    def DeleteAllAtoms(self): return _mmut.Residue_DeleteAllAtoms(self)
    def DeleteAltLocs(self): return _mmut.Residue_DeleteAltLocs(self)
    def TrimAtomTable(self): return _mmut.Residue_TrimAtomTable(self)
    def AddAtom(self, *args): return _mmut.Residue_AddAtom(self, *args)
    def InsertAtom(self, *args): return _mmut.Residue_InsertAtom(self, *args)
    def ApplyTransform(self, *args): return _mmut.Residue_ApplyTransform(self, *args)
    def MaskAtoms(self, *args): return _mmut.Residue_MaskAtoms(self, *args)
    def UnmaskAtoms(self, *args): return _mmut.Residue_UnmaskAtoms(self, *args)
    def PutUDData(self, *args): return _mmut.Residue_PutUDData(self, *args)
    def GetUDData(self, *args): return _mmut.Residue_GetUDData(self, *args)
    def isMainchainHBond(self, *args): return _mmut.Residue_isMainchainHBond(self, *args)
    def Copy(self, *args): return _mmut.Residue_Copy(self, *args)
Residue_swigregister = _mmut.Residue_swigregister
Residue_swigregister(Residue)

MMDBF_AutoSerials = _mmut.MMDBF_AutoSerials
MMDBF_NoCoordRead = _mmut.MMDBF_NoCoordRead
MMDBF_SimRWBROOK = _mmut.MMDBF_SimRWBROOK
MMDBF_PrintCIFWarnings = _mmut.MMDBF_PrintCIFWarnings
MMDBF_EnforceSpaces = _mmut.MMDBF_EnforceSpaces
MMDBF_IgnoreDuplSeqNum = _mmut.MMDBF_IgnoreDuplSeqNum
MMDBF_IgnoreSegID = _mmut.MMDBF_IgnoreSegID
MMDBF_IgnoreElement = _mmut.MMDBF_IgnoreElement
MMDBF_IgnoreCharge = _mmut.MMDBF_IgnoreCharge
MMDBF_IgnoreNonCoorPDBErrors = _mmut.MMDBF_IgnoreNonCoorPDBErrors
MMDBF_IgnoreUnmatch = _mmut.MMDBF_IgnoreUnmatch
MMDBF_IgnoreBlankLines = _mmut.MMDBF_IgnoreBlankLines
MMDBF_IgnoreHash = _mmut.MMDBF_IgnoreHash
MMDBF_IgnoreRemarks = _mmut.MMDBF_IgnoreRemarks
MMDBF_AllowDuplChainID = _mmut.MMDBF_AllowDuplChainID
MMDBF_FixSpaceGroup = _mmut.MMDBF_FixSpaceGroup
MMDBF_EnforceAtomNames = _mmut.MMDBF_EnforceAtomNames
MMDBF_EnforceUniqueChainID = _mmut.MMDBF_EnforceUniqueChainID
MMDB_FILE_Undefined = _mmut.MMDB_FILE_Undefined
MMDB_FILE_PDB = _mmut.MMDB_FILE_PDB
MMDB_FILE_CIF = _mmut.MMDB_FILE_CIF
MMDB_FILE_Binary = _mmut.MMDB_FILE_Binary
PDBCLEAN_ATNAME = _mmut.PDBCLEAN_ATNAME
PDBCLEAN_TER = _mmut.PDBCLEAN_TER
PDBCLEAN_CHAIN = _mmut.PDBCLEAN_CHAIN
PDBCLEAN_CHAIN_STRONG = _mmut.PDBCLEAN_CHAIN_STRONG
PDBCLEAN_ALTCODE = _mmut.PDBCLEAN_ALTCODE
PDBCLEAN_ALTCODE_STRONG = _mmut.PDBCLEAN_ALTCODE_STRONG
PDBCLEAN_SERIAL = _mmut.PDBCLEAN_SERIAL
PDBCLEAN_SEQNUM = _mmut.PDBCLEAN_SEQNUM
PDBCLEAN_CHAIN_ORDER = _mmut.PDBCLEAN_CHAIN_ORDER
PDBCLEAN_CHAIN_ORDER_IX = _mmut.PDBCLEAN_CHAIN_ORDER_IX
PDBCLEAN_SOLVENT = _mmut.PDBCLEAN_SOLVENT
PDBCLEAN_INDEX = _mmut.PDBCLEAN_INDEX
PDBCLEAN_ELEMENT = _mmut.PDBCLEAN_ELEMENT
PDBCLEAN_ELEMENT_STRONG = _mmut.PDBCLEAN_ELEMENT_STRONG
CRRDY_NotPrecise = _mmut.CRRDY_NotPrecise
CRRDY_isTranslation = _mmut.CRRDY_isTranslation
CRRDY_NoOrthCode = _mmut.CRRDY_NoOrthCode
CRRDY_Complete = _mmut.CRRDY_Complete
CRRDY_NoTransfMatrices = _mmut.CRRDY_NoTransfMatrices
CRRDY_Unchecked = _mmut.CRRDY_Unchecked
CRRDY_Ambiguous = _mmut.CRRDY_Ambiguous
CRRDY_NoCell = _mmut.CRRDY_NoCell
CRRDY_NoSpaceGroup = _mmut.CRRDY_NoSpaceGroup
class Root(UDData):
    __swig_setmethods__ = {}
    for _s in [UDData]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Root, name, value)
    __swig_getmethods__ = {}
    for _s in [UDData]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Root, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _mmut.delete_Root
    __del__ = lambda self : None;
    def FreeFileMemory(self): return _mmut.Root_FreeFileMemory(self)
    def SetFlag(self, *args): return _mmut.Root_SetFlag(self, *args)
    def RemoveFlag(self, *args): return _mmut.Root_RemoveFlag(self, *args)
    def ReadPDBASCII(self, *args): return _mmut.Root_ReadPDBASCII(self, *args)
    def ReadPDBASCII1(self, *args): return _mmut.Root_ReadPDBASCII1(self, *args)
    def ReadCIFASCII(self, *args): return _mmut.Root_ReadCIFASCII(self, *args)
    def ReadCIFASCII1(self, *args): return _mmut.Root_ReadCIFASCII1(self, *args)
    def ReadFromCIF(self, *args): return _mmut.Root_ReadFromCIF(self, *args)
    def AddPDBASCII1(self, *args): return _mmut.Root_AddPDBASCII1(self, *args)
    def AddPDBASCII(self, *args): return _mmut.Root_AddPDBASCII(self, *args)
    def ReadCoorFile(self, *args): return _mmut.Root_ReadCoorFile(self, *args)
    def ReadCoorFile1(self, *args): return _mmut.Root_ReadCoorFile1(self, *args)
    def WritePDBASCII(self, *args): return _mmut.Root_WritePDBASCII(self, *args)
    def WritePDBASCII1(self, *args): return _mmut.Root_WritePDBASCII1(self, *args)
    def WriteCIFASCII(self, *args): return _mmut.Root_WriteCIFASCII(self, *args)
    def WriteCIFASCII1(self, *args): return _mmut.Root_WriteCIFASCII1(self, *args)
    def ReadMMDBF(self, *args): return _mmut.Root_ReadMMDBF(self, *args)
    def ReadMMDBF1(self, *args): return _mmut.Root_ReadMMDBF1(self, *args)
    def WriteMMDBF(self, *args): return _mmut.Root_WriteMMDBF(self, *args)
    def WriteMMDBF1(self, *args): return _mmut.Root_WriteMMDBF1(self, *args)
    def GetInputBuffer(self, *args): return _mmut.Root_GetInputBuffer(self, *args)
    def PutPDBString(self, *args): return _mmut.Root_PutPDBString(self, *args)
    def PDBCleanup(self, *args): return _mmut.Root_PDBCleanup(self, *args)
    def MakeHetAtoms(self, *args): return _mmut.Root_MakeHetAtoms(self, *args)
    def GetAtomArray(self): return _mmut.Root_GetAtomArray(self)
    def GetAtomArrayLength(self): return _mmut.Root_GetAtomArrayLength(self)
    def GetAtomI(self, *args): return _mmut.Root_GetAtomI(self, *args)
    def PutAtom(self, *args): return _mmut.Root_PutAtom(self, *args)
    def RemoveAtom(self, *args): return _mmut.Root_RemoveAtom(self, *args)
    def FinishStructEdit(self): return _mmut.Root_FinishStructEdit(self)
    def TrimModelTable(self): return _mmut.Root_TrimModelTable(self)
    def DeleteAllModels(self): return _mmut.Root_DeleteAllModels(self)
    def GetNewChainID(self, *args): return _mmut.Root_GetNewChainID(self, *args)
    def CrystReady(self): return _mmut.Root_CrystReady(self)
    def isCrystInfo(self): return _mmut.Root_isCrystInfo(self)
    def isCellInfo(self): return _mmut.Root_isCellInfo(self)
    def isSpaceGroup(self): return _mmut.Root_isSpaceGroup(self)
    def isTransfMatrix(self): return _mmut.Root_isTransfMatrix(self)
    def isScaleMatrix(self): return _mmut.Root_isScaleMatrix(self)
    def isNCSMatrix(self): return _mmut.Root_isNCSMatrix(self)
    def GetNumberOfNCSMatrices(self): return _mmut.Root_GetNumberOfNCSMatrices(self)
    def GetNumberOfNCSMates(self): return _mmut.Root_GetNumberOfNCSMates(self)
    def GetNCSMatrix(self, *args): return _mmut.Root_GetNCSMatrix(self, *args)
    def GetNumberOfSymOps(self): return _mmut.Root_GetNumberOfSymOps(self)
    def GetSymOp(self, *args): return _mmut.Root_GetSymOp(self, *args)
    def RegisterUDInteger(self, *args): return _mmut.Root_RegisterUDInteger(self, *args)
    def RegisterUDReal(self, *args): return _mmut.Root_RegisterUDReal(self, *args)
    def RegisterUDString(self, *args): return _mmut.Root_RegisterUDString(self, *args)
    def GetUDDHandle(self, *args): return _mmut.Root_GetUDDHandle(self, *args)
    def SetSyminfoLib(self, *args): return _mmut.Root_SetSyminfoLib(self, *args)
    def GetSyminfoLib(self): return _mmut.Root_GetSyminfoLib(self)
    def SetSpaceGroup(self, *args): return _mmut.Root_SetSpaceGroup(self, *args)
    def GetSpaceGroup(self): return _mmut.Root_GetSpaceGroup(self)
    def GetSpaceGroupFix(self): return _mmut.Root_GetSpaceGroupFix(self)
    def SetIgnoreSCALEi(self, *args): return _mmut.Root_SetIgnoreSCALEi(self, *args)
    def SetCell(self, *args): return _mmut.Root_SetCell(self, *args)
    def PutCell(self, *args): return _mmut.Root_PutCell(self, *args)
    def GetCell(self, *args): return _mmut.Root_GetCell(self, *args)
    def GetRCell(self, *args): return _mmut.Root_GetRCell(self, *args)
    def GetROMatrix(self, *args): return _mmut.Root_GetROMatrix(self, *args)
    def GetTMatrix(self, *args): return _mmut.Root_GetTMatrix(self, *args)
    def GetUCTMatrix(self, *args): return _mmut.Root_GetUCTMatrix(self, *args)
    def GetFractMatrix(self, *args): return _mmut.Root_GetFractMatrix(self, *args)
    def GetSymOpMatrix(self, *args): return _mmut.Root_GetSymOpMatrix(self, *args)
    def AddNCSMatrix(self, *args): return _mmut.Root_AddNCSMatrix(self, *args)
    def GenerateNCSMates(self): return _mmut.Root_GenerateNCSMates(self)
    def GetEntryID(self): return _mmut.Root_GetEntryID(self)
    def SetEntryID(self, *args): return _mmut.Root_SetEntryID(self, *args)
    def GetNofExpDataRecs(self): return _mmut.Root_GetNofExpDataRecs(self)
    def GetExpDataRec(self, *args): return _mmut.Root_GetExpDataRec(self, *args)
    def GetNofMdlTypeRecs(self): return _mmut.Root_GetNofMdlTypeRecs(self)
    def GetMdlTypeRec(self, *args): return _mmut.Root_GetMdlTypeRec(self, *args)
    def GetFileType(self): return _mmut.Root_GetFileType(self)
    def Copy(self, *args): return _mmut.Root_Copy(self, *args)
    def SetShortBinary(self): return _mmut.Root_SetShortBinary(self)
    def PutUDData(self, *args): return _mmut.Root_PutUDData(self, *args)
    def GetUDData(self, *args): return _mmut.Root_GetUDData(self, *args)
    def GetStructureTitle(self, *args): return _mmut.Root_GetStructureTitle(self, *args)
    def GetCrystData(self): return _mmut.Root_GetCrystData(self)
    def GetUnparsedA(self): return _mmut.Root_GetUnparsedA(self)
    def GetUnparsedB(self): return _mmut.Root_GetUnparsedB(self)
    def GetUnparsedC(self): return _mmut.Root_GetUnparsedC(self)
Root_swigregister = _mmut.Root_swigregister
Root_swigregister(Root)

BRICK_ON_1 = _mmut.BRICK_ON_1
BRICK_ON_2 = _mmut.BRICK_ON_2
BRICK_READY = _mmut.BRICK_READY
class Brick(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Brick, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Brick, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nAtoms"] = _mmut.Brick_nAtoms_set
    __swig_getmethods__["nAtoms"] = _mmut.Brick_nAtoms_get
    if _newclass:nAtoms = _swig_property(_mmut.Brick_nAtoms_get, _mmut.Brick_nAtoms_set)
    __swig_setmethods__["atom"] = _mmut.Brick_atom_set
    __swig_getmethods__["atom"] = _mmut.Brick_atom_get
    if _newclass:atom = _swig_property(_mmut.Brick_atom_get, _mmut.Brick_atom_set)
    __swig_setmethods__["id"] = _mmut.Brick_id_set
    __swig_getmethods__["id"] = _mmut.Brick_id_get
    if _newclass:id = _swig_property(_mmut.Brick_id_get, _mmut.Brick_id_set)
    def __init__(self): 
        this = _mmut.new_Brick()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Brick
    __del__ = lambda self : None;
    def Clear(self): return _mmut.Brick_Clear(self)
    def AddAtom(self, *args): return _mmut.Brick_AddAtom(self, *args)
Brick_swigregister = _mmut.Brick_swigregister
Brick_swigregister(Brick)

class MBrick(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MBrick, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MBrick, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nAtoms"] = _mmut.MBrick_nAtoms_set
    __swig_getmethods__["nAtoms"] = _mmut.MBrick_nAtoms_get
    if _newclass:nAtoms = _swig_property(_mmut.MBrick_nAtoms_get, _mmut.MBrick_nAtoms_set)
    __swig_setmethods__["atom"] = _mmut.MBrick_atom_set
    __swig_getmethods__["atom"] = _mmut.MBrick_atom_get
    if _newclass:atom = _swig_property(_mmut.MBrick_atom_get, _mmut.MBrick_atom_set)
    __swig_setmethods__["id"] = _mmut.MBrick_id_set
    __swig_getmethods__["id"] = _mmut.MBrick_id_get
    if _newclass:id = _swig_property(_mmut.MBrick_id_get, _mmut.MBrick_id_set)
    def __init__(self, *args): 
        this = _mmut.new_MBrick(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_MBrick
    __del__ = lambda self : None;
    def Clear(self): return _mmut.MBrick_Clear(self)
    def AddAtom(self, *args): return _mmut.MBrick_AddAtom(self, *args)
MBrick_swigregister = _mmut.MBrick_swigregister
MBrick_swigregister(MBrick)

class GenSym(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenSym, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GenSym, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_GenSym()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_GenSym
    __del__ = lambda self : None;
    def FreeMemory(self): return _mmut.GenSym_FreeMemory(self)
    def AddSymOp(self, *args): return _mmut.GenSym_AddSymOp(self, *args)
    def AddRenChain(self, *args): return _mmut.GenSym_AddRenChain(self, *args)
    def Copy(self, *args): return _mmut.GenSym_Copy(self, *args)
GenSym_swigregister = _mmut.GenSym_swigregister
GenSym_swigregister(GenSym)

class Contact(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Contact, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Contact, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id1"] = _mmut.Contact_id1_set
    __swig_getmethods__["id1"] = _mmut.Contact_id1_get
    if _newclass:id1 = _swig_property(_mmut.Contact_id1_get, _mmut.Contact_id1_set)
    __swig_setmethods__["id2"] = _mmut.Contact_id2_set
    __swig_getmethods__["id2"] = _mmut.Contact_id2_get
    if _newclass:id2 = _swig_property(_mmut.Contact_id2_get, _mmut.Contact_id2_set)
    __swig_setmethods__["group"] = _mmut.Contact_group_set
    __swig_getmethods__["group"] = _mmut.Contact_group_get
    if _newclass:group = _swig_property(_mmut.Contact_group_get, _mmut.Contact_group_set)
    __swig_setmethods__["dist"] = _mmut.Contact_dist_set
    __swig_getmethods__["dist"] = _mmut.Contact_dist_get
    if _newclass:dist = _swig_property(_mmut.Contact_dist_get, _mmut.Contact_dist_set)
    def __init__(self): 
        this = _mmut.new_Contact()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Contact
    __del__ = lambda self : None;
Contact_swigregister = _mmut.Contact_swigregister
Contact_swigregister(Contact)

class MContact(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MContact, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MContact, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nStruct"] = _mmut.MContact_nStruct_set
    __swig_getmethods__["nStruct"] = _mmut.MContact_nStruct_get
    if _newclass:nStruct = _swig_property(_mmut.MContact_nStruct_get, _mmut.MContact_nStruct_set)
    __swig_setmethods__["contactID"] = _mmut.MContact_contactID_set
    __swig_getmethods__["contactID"] = _mmut.MContact_contactID_get
    if _newclass:contactID = _swig_property(_mmut.MContact_contactID_get, _mmut.MContact_contactID_set)
    __swig_setmethods__["nAtoms"] = _mmut.MContact_nAtoms_set
    __swig_getmethods__["nAtoms"] = _mmut.MContact_nAtoms_get
    if _newclass:nAtoms = _swig_property(_mmut.MContact_nAtoms_get, _mmut.MContact_nAtoms_set)
    __swig_setmethods__["atom"] = _mmut.MContact_atom_set
    __swig_getmethods__["atom"] = _mmut.MContact_atom_get
    if _newclass:atom = _swig_property(_mmut.MContact_atom_get, _mmut.MContact_atom_set)
    __swig_setmethods__["id"] = _mmut.MContact_id_set
    __swig_getmethods__["id"] = _mmut.MContact_id_get
    if _newclass:id = _swig_property(_mmut.MContact_id_get, _mmut.MContact_id_set)
    def __init__(self, *args): 
        this = _mmut.new_MContact(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_MContact
    __del__ = lambda self : None;
    def AddContact(self, *args): return _mmut.MContact_AddContact(self, *args)
MContact_swigregister = _mmut.MContact_swigregister
MContact_swigregister(MContact)


def DeleteMContacts(*args):
  return _mmut.DeleteMContacts(*args)
DeleteMContacts = _mmut.DeleteMContacts
CID_Ok = _mmut.CID_Ok
CID_NoModel = _mmut.CID_NoModel
CID_NoChain = _mmut.CID_NoChain
CID_NoResidue = _mmut.CID_NoResidue
CID_NoAtom = _mmut.CID_NoAtom
CID_WrongPath = _mmut.CID_WrongPath
GSM_Ok = _mmut.GSM_Ok
GSM_NoSymOps = _mmut.GSM_NoSymOps
GSM_NoTransfMatrices = _mmut.GSM_NoTransfMatrices
GSM_NoCell = _mmut.GSM_NoCell
class CoorManager(Root):
    __swig_setmethods__ = {}
    for _s in [Root]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoorManager, name, value)
    __swig_getmethods__ = {}
    for _s in [Root]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoorManager, name)
    __repr__ = _swig_repr
    __swig_setmethods__["CoorIDCode"] = _mmut.CoorManager_CoorIDCode_set
    __swig_getmethods__["CoorIDCode"] = _mmut.CoorManager_CoorIDCode_get
    if _newclass:CoorIDCode = _swig_property(_mmut.CoorManager_CoorIDCode_get, _mmut.CoorManager_CoorIDCode_set)
    def __init__(self): 
        this = _mmut.new_CoorManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CoorManager
    __del__ = lambda self : None;
    def SetDefaultCoorID(self, *args): return _mmut.CoorManager_SetDefaultCoorID(self, *args)
    def RemoveBricks(self): return _mmut.CoorManager_RemoveBricks(self)
    def areBricks(self): return _mmut.CoorManager_areBricks(self)
    def MakeBricks(self, *args): return _mmut.CoorManager_MakeBricks(self, *args)
    def GetBrickDimension(self, *args): return _mmut.CoorManager_GetBrickDimension(self, *args)
    def GetBrickCoor(self, *args): return _mmut.CoorManager_GetBrickCoor(self, *args)
    def GetBrick(self, *args): return _mmut.CoorManager_GetBrick(self, *args)
    def RemoveMBricks(self): return _mmut.CoorManager_RemoveMBricks(self)
    def areMBricks(self): return _mmut.CoorManager_areMBricks(self)
    def MakeMBricks(self, *args): return _mmut.CoorManager_MakeMBricks(self, *args)
    def GetMBrickDimension(self, *args): return _mmut.CoorManager_GetMBrickDimension(self, *args)
    def GetMBrickCoor(self, *args): return _mmut.CoorManager_GetMBrickCoor(self, *args)
    def GetMBrick(self, *args): return _mmut.CoorManager_GetMBrick(self, *args)
    def GetNumberOfModels(self): return _mmut.CoorManager_GetNumberOfModels(self)
    def GetFirstModelNum(self): return _mmut.CoorManager_GetFirstModelNum(self)
    def GetFirstDefinedModel(self): return _mmut.CoorManager_GetFirstDefinedModel(self)
    def GetModel(self, *args): return _mmut.CoorManager_GetModel(self, *args)
    def GetModelTable(self, *args): return _mmut.CoorManager_GetModelTable(self, *args)
    def DeleteModel(self, *args): return _mmut.CoorManager_DeleteModel(self, *args)
    def AddModel(self, *args): return _mmut.CoorManager_AddModel(self, *args)
    def InsModel(self, *args): return _mmut.CoorManager_InsModel(self, *args)
    def RotateModels(self, *args): return _mmut.CoorManager_RotateModels(self, *args)
    def SwapModels(self, *args): return _mmut.CoorManager_SwapModels(self, *args)
    def GetNumberOfChains(self, *args): return _mmut.CoorManager_GetNumberOfChains(self, *args)
    def GetChain(self, *args): return _mmut.CoorManager_GetChain(self, *args)
    def GetChainTable(self, *args): return _mmut.CoorManager_GetChainTable(self, *args)
    def DeleteChain(self, *args): return _mmut.CoorManager_DeleteChain(self, *args)
    def DeleteAllChains(self, *args): return _mmut.CoorManager_DeleteAllChains(self, *args)
    def AddChain(self, *args): return _mmut.CoorManager_AddChain(self, *args)
    def GetNumberOfResidues(self, *args): return _mmut.CoorManager_GetNumberOfResidues(self, *args)
    def GetResidue(self, *args): return _mmut.CoorManager_GetResidue(self, *args)
    def GetResidueNo(self, *args): return _mmut.CoorManager_GetResidueNo(self, *args)
    def GetResidueTable(self, *args): return _mmut.CoorManager_GetResidueTable(self, *args)
    def DeleteResidue(self, *args): return _mmut.CoorManager_DeleteResidue(self, *args)
    def DeleteAllResidues(self, *args): return _mmut.CoorManager_DeleteAllResidues(self, *args)
    def DeleteSolvent(self): return _mmut.CoorManager_DeleteSolvent(self)
    def AddResidue(self, *args): return _mmut.CoorManager_AddResidue(self, *args)
    def GetNumberOfAtoms(self, *args): return _mmut.CoorManager_GetNumberOfAtoms(self, *args)
    def GetAtom(self, *args): return _mmut.CoorManager_GetAtom(self, *args)
    def GetAtomTable(self, *args): return _mmut.CoorManager_GetAtomTable(self, *args)
    def GetAtomTable1(self, *args): return _mmut.CoorManager_GetAtomTable1(self, *args)
    def DeleteAtom(self, *args): return _mmut.CoorManager_DeleteAtom(self, *args)
    def DeleteAllAtoms(self, *args): return _mmut.CoorManager_DeleteAllAtoms(self, *args)
    def DeleteAltLocs(self): return _mmut.CoorManager_DeleteAltLocs(self)
    def AddAtom(self, *args): return _mmut.CoorManager_AddAtom(self, *args)
    def GenerateSymMates(self, genSym=0): return _mmut.CoorManager_GenerateSymMates(self, genSym)
    def ApplyTransform(self, *args): return _mmut.CoorManager_ApplyTransform(self, *args)
    def BringToUnitCell(self): return _mmut.CoorManager_BringToUnitCell(self)
    def Frac2Orth(self, *args): return _mmut.CoorManager_Frac2Orth(self, *args)
    def Orth2Frac(self, *args): return _mmut.CoorManager_Orth2Frac(self, *args)
    def SeekContacts(self, *args): return _mmut.CoorManager_SeekContacts(self, *args)
CoorManager_swigregister = _mmut.CoorManager_swigregister
CoorManager_swigregister(CoorManager)


def GetEulerRotMatrix(*args):
  return _mmut.GetEulerRotMatrix(*args)
GetEulerRotMatrix = _mmut.GetEulerRotMatrix

def GetEulerTMatrix(*args):
  return _mmut.GetEulerTMatrix(*args)
GetEulerTMatrix = _mmut.GetEulerTMatrix

def EulerRotation(*args):
  return _mmut.EulerRotation(*args)
EulerRotation = _mmut.EulerRotation

def GetVecRotMatrix(*args):
  return _mmut.GetVecRotMatrix(*args)
GetVecRotMatrix = _mmut.GetVecRotMatrix

def GetRotParameters(*args):
  return _mmut.GetRotParameters(*args)
GetRotParameters = _mmut.GetRotParameters

def GetVecTMatrix(*args):
  return _mmut.GetVecTMatrix(*args)
GetVecTMatrix = _mmut.GetVecTMatrix

def VectorRotation(*args):
  return _mmut.VectorRotation(*args)
VectorRotation = _mmut.VectorRotation

def GetMassCenter(*args):
  return _mmut.GetMassCenter(*args)
GetMassCenter = _mmut.GetMassCenter
SPOSEAT_Ok = _mmut.SPOSEAT_Ok
SPOSEAT_NoAtoms = _mmut.SPOSEAT_NoAtoms
SPOSEAT_SVD_Fail = _mmut.SPOSEAT_SVD_Fail

def SuperposeAtoms(*args):
  return _mmut.SuperposeAtoms(*args)
SuperposeAtoms = _mmut.SuperposeAtoms
CNSORT_OFF = _mmut.CNSORT_OFF
CNSORT_1INC = _mmut.CNSORT_1INC
CNSORT_1DEC = _mmut.CNSORT_1DEC
CNSORT_2INC = _mmut.CNSORT_2INC
CNSORT_2DEC = _mmut.CNSORT_2DEC
CNSORT_DINC = _mmut.CNSORT_DINC
CNSORT_DDEC = _mmut.CNSORT_DDEC

def SortContacts(*args):
  return _mmut.SortContacts(*args)
SortContacts = _mmut.SortContacts

def getPhi(*args):
  return _mmut.getPhi(*args)
getPhi = _mmut.getPhi

def getPsi(*args):
  return _mmut.getPsi(*args)
getPsi = _mmut.getPsi
SKEY_NEW = _mmut.SKEY_NEW
SKEY_OR = _mmut.SKEY_OR
SKEY_AND = _mmut.SKEY_AND
SKEY_XOR = _mmut.SKEY_XOR
SKEY_CLR = _mmut.SKEY_CLR
SKEY_XAND = _mmut.SKEY_XAND
STYPE_INVALID = _mmut.STYPE_INVALID
STYPE_UNDEFINED = _mmut.STYPE_UNDEFINED
STYPE_ATOM = _mmut.STYPE_ATOM
STYPE_RESIDUE = _mmut.STYPE_RESIDUE
STYPE_CHAIN = _mmut.STYPE_CHAIN
STYPE_MODEL = _mmut.STYPE_MODEL
SELPROP_Solvent = _mmut.SELPROP_Solvent
SELPROP_Aminoacid = _mmut.SELPROP_Aminoacid
SELPROP_Nucleotide = _mmut.SELPROP_Nucleotide
SELPROP_Sugar = _mmut.SELPROP_Sugar
SELPROP_ModRes = _mmut.SELPROP_ModRes
UDSCR_LT = _mmut.UDSCR_LT
UDSCR_LE = _mmut.UDSCR_LE
UDSCR_EQ = _mmut.UDSCR_EQ
UDSCR_NE = _mmut.UDSCR_NE
UDSCR_GE = _mmut.UDSCR_GE
UDSCR_GT = _mmut.UDSCR_GT
UDSCR_LTcase = _mmut.UDSCR_LTcase
UDSCR_LEcase = _mmut.UDSCR_LEcase
UDSCR_EQcase = _mmut.UDSCR_EQcase
UDSCR_NEcase = _mmut.UDSCR_NEcase
UDSCR_GEcase = _mmut.UDSCR_GEcase
UDSCR_GTcase = _mmut.UDSCR_GTcase
UDSCR_LTn = _mmut.UDSCR_LTn
UDSCR_LEn = _mmut.UDSCR_LEn
UDSCR_EQn = _mmut.UDSCR_EQn
UDSCR_NEn = _mmut.UDSCR_NEn
UDSCR_GEn = _mmut.UDSCR_GEn
UDSCR_GTn = _mmut.UDSCR_GTn
UDSCR_LTncase = _mmut.UDSCR_LTncase
UDSCR_LEncase = _mmut.UDSCR_LEncase
UDSCR_EQncase = _mmut.UDSCR_EQncase
UDSCR_NEncase = _mmut.UDSCR_NEncase
UDSCR_GEncase = _mmut.UDSCR_GEncase
UDSCR_GTncase = _mmut.UDSCR_GTncase
UDSCR_Substr = _mmut.UDSCR_Substr
UDSCR_NoSubstr = _mmut.UDSCR_NoSubstr
UDSCR_Substr1 = _mmut.UDSCR_Substr1
UDSCR_NoSubstr1 = _mmut.UDSCR_NoSubstr1
class SelManager(CoorManager):
    __swig_setmethods__ = {}
    for _s in [CoorManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SelManager, name, value)
    __swig_getmethods__ = {}
    for _s in [CoorManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SelManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_SelManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_SelManager
    __del__ = lambda self : None;
    def NewSelection(self): return _mmut.SelManager_NewSelection(self)
    def GetSelType(self, *args): return _mmut.SelManager_GetSelType(self, *args)
    def DeleteSelection(self, *args): return _mmut.SelManager_DeleteSelection(self, *args)
    def DeleteAllSelections(self): return _mmut.SelManager_DeleteAllSelections(self)
    def UnselectAtoms(self, *args): return _mmut.SelManager_UnselectAtoms(self, *args)
    def SelectAtom(self, *args): return _mmut.SelManager_SelectAtom(self, *args)
    def SelectResidue(self, *args): return _mmut.SelManager_SelectResidue(self, *args)
    def SelectChain(self, *args): return _mmut.SelManager_SelectChain(self, *args)
    def SelectModel(self, *args): return _mmut.SelManager_SelectModel(self, *args)
    def MakeSelIndex(self, *args): return _mmut.SelManager_MakeSelIndex(self, *args)
    def MakeAllSelIndexes(self): return _mmut.SelManager_MakeAllSelIndexes(self)
    def SelectAtoms(self, *args): return _mmut.SelManager_SelectAtoms(self, *args)
    def SelectUDD(self, *args): return _mmut.SelManager_SelectUDD(self, *args)
    def SelectSphere(self, *args): return _mmut.SelManager_SelectSphere(self, *args)
    def SelectCylinder(self, *args): return _mmut.SelManager_SelectCylinder(self, *args)
    def SelectSlab(self, *args): return _mmut.SelManager_SelectSlab(self, *args)
    def SelectNeighbours(self, *args): return _mmut.SelManager_SelectNeighbours(self, *args)
    def GetSelLength(self, *args): return _mmut.SelManager_GetSelLength(self, *args)
    def GetSelIndex(self, *args): return _mmut.SelManager_GetSelIndex(self, *args)
    def Select(self, *args): return _mmut.SelManager_Select(self, *args)
    def SelectProperty(self, *args): return _mmut.SelManager_SelectProperty(self, *args)
    def SelectDomain(self, *args): return _mmut.SelManager_SelectDomain(self, *args)
    def DeleteSelObjects(self, *args): return _mmut.SelManager_DeleteSelObjects(self, *args)
SelManager_swigregister = _mmut.SelManager_swigregister
SelManager_swigregister(SelManager)
NO_TORSION = cvar.NO_TORSION

class BondManager(SelManager):
    __swig_setmethods__ = {}
    for _s in [SelManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BondManager, name, value)
    __swig_getmethods__ = {}
    for _s in [SelManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BondManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_BondManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_BondManager
    __del__ = lambda self : None;
    def MakeBonds(self, *args): return _mmut.BondManager_MakeBonds(self, *args)
    def RemoveBonds(self): return _mmut.BondManager_RemoveBonds(self)
BondManager_swigregister = _mmut.BondManager_swigregister
BondManager_swigregister(BondManager)

MMDBFCM_None = _mmut.MMDBFCM_None
MMDBFCM_All = _mmut.MMDBFCM_All
MMDBFCM_Title = _mmut.MMDBFCM_Title
MMDBFCM_TitleKeepBM = _mmut.MMDBFCM_TitleKeepBM
MMDBFCM_Cryst = _mmut.MMDBFCM_Cryst
MMDBFCM_Coord = _mmut.MMDBFCM_Coord
MMDBFCM_SecStruct = _mmut.MMDBFCM_SecStruct
MMDBFCM_HetInfo = _mmut.MMDBFCM_HetInfo
MMDBFCM_Links = _mmut.MMDBFCM_Links
MMDBFCM_CisPeps = _mmut.MMDBFCM_CisPeps
MMDBFCM_SA = _mmut.MMDBFCM_SA
MMDBFCM_SB = _mmut.MMDBFCM_SB
MMDBFCM_SC = _mmut.MMDBFCM_SC
MMDBFCM_Footnotes = _mmut.MMDBFCM_Footnotes
MMDBFCM_ChainAnnot = _mmut.MMDBFCM_ChainAnnot
MMDBFCM_Flags = _mmut.MMDBFCM_Flags
MMDBFCM_Buffer = _mmut.MMDBFCM_Buffer
MMDBFCM_Top = _mmut.MMDBFCM_Top
class Manager(BondManager):
    __swig_setmethods__ = {}
    for _s in [BondManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Manager, name, value)
    __swig_getmethods__ = {}
    for _s in [BondManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Manager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_Manager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Manager
    __del__ = lambda self : None;
    def Copy(self, *args): return _mmut.Manager_Copy(self, *args)
    def Delete(self, *args): return _mmut.Manager_Delete(self, *args)
    def GetRemarks(self): return _mmut.Manager_GetRemarks(self)
    def GetJournal(self): return _mmut.Manager_GetJournal(self)
    def GetResolution(self): return _mmut.Manager_GetResolution(self)
    def ParseBiomolecules(self): return _mmut.Manager_ParseBiomolecules(self)
    def GetNofBiomolecules(self): return _mmut.Manager_GetNofBiomolecules(self)
    def GetBiomolecules(self, *args): return _mmut.Manager_GetBiomolecules(self, *args)
    def GetBiomolecule(self, *args): return _mmut.Manager_GetBiomolecule(self, *args)
    def MakeBiomolecule(self, *args): return _mmut.Manager_MakeBiomolecule(self, *args)
Manager_swigregister = _mmut.Manager_swigregister
Manager_swigregister(Manager)

MMCIF_Category = _mmut.MMCIF_Category
MMCIF_Struct = _mmut.MMCIF_Struct
MMCIF_Loop = _mmut.MMCIF_Loop
MMCIF_Data = _mmut.MMCIF_Data
class Category(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Category, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Category, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Category(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Category
    __del__ = lambda self : None;
    def GetCategoryName(self): return _mmut.Category_GetCategoryName(self)
    def SetCategoryName(self, *args): return _mmut.Category_SetCategoryName(self, *args)
    def GetCategoryID(self): return _mmut.Category_GetCategoryID(self)
    def Optimize(self): return _mmut.Category_Optimize(self)
    def Sort(self): return _mmut.Category_Sort(self)
    def GetTagNo(self, *args): return _mmut.Category_GetTagNo(self, *args)
    def AddTag(self, *args): return _mmut.Category_AddTag(self, *args)
    def GetNofTags(self): return _mmut.Category_GetNofTags(self)
    def GetTag(self, *args): return _mmut.Category_GetTag(self, *args)
    def PrintTags(self): return _mmut.Category_PrintTags(self)
    def CheckTags(self, *args): return _mmut.Category_CheckTags(self, *args)
    def Copy(self, *args): return _mmut.Category_Copy(self, *args)
Category_swigregister = _mmut.Category_swigregister
Category_swigregister(Category)

class Struct(Category):
    __swig_setmethods__ = {}
    for _s in [Category]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Struct, name, value)
    __swig_getmethods__ = {}
    for _s in [Category]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Struct, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Struct(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Struct
    __del__ = lambda self : None;
    def AddField(self, *args): return _mmut.Struct_AddField(self, *args)
    def GetCategoryID(self): return _mmut.Struct_GetCategoryID(self)
    def Optimize(self): return _mmut.Struct_Optimize(self)
    def GetField(self, *args): return _mmut.Struct_GetField(self, *args)
    def GetString(self, *args): return _mmut.Struct_GetString(self, *args)
    def DeleteField(self, *args): return _mmut.Struct_DeleteField(self, *args)
    def GetReal(self, *args): return _mmut.Struct_GetReal(self, *args)
    def GetInteger(self, *args): return _mmut.Struct_GetInteger(self, *args)
    def PutString(self, *args): return _mmut.Struct_PutString(self, *args)
    def PutDate(self, *args): return _mmut.Struct_PutDate(self, *args)
    def PutNoData(self, *args): return _mmut.Struct_PutNoData(self, *args)
    def PutReal(self, *args): return _mmut.Struct_PutReal(self, *args)
    def PutInteger(self, *args): return _mmut.Struct_PutInteger(self, *args)
    def WriteMMCIFStruct(self, *args): return _mmut.Struct_WriteMMCIFStruct(self, *args)
    def Copy(self, *args): return _mmut.Struct_Copy(self, *args)
Struct_swigregister = _mmut.Struct_swigregister
Struct_swigregister(Struct)
CIF_NODATA_DOT = cvar.CIF_NODATA_DOT
CIF_NODATA_QUESTION = cvar.CIF_NODATA_QUESTION

class Loop(Category):
    __swig_setmethods__ = {}
    for _s in [Category]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Loop, name, value)
    __swig_getmethods__ = {}
    for _s in [Category]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Loop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Loop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Loop
    __del__ = lambda self : None;
    def AddLoopTag(self, *args): return _mmut.Loop_AddLoopTag(self, *args)
    def AddString(self, *args): return _mmut.Loop_AddString(self, *args)
    def AddNoData(self, *args): return _mmut.Loop_AddNoData(self, *args)
    def AddReal(self, *args): return _mmut.Loop_AddReal(self, *args)
    def AddInteger(self, *args): return _mmut.Loop_AddInteger(self, *args)
    def GetLoopLength(self): return _mmut.Loop_GetLoopLength(self)
    def GetField(self, *args): return _mmut.Loop_GetField(self, *args)
    def GetString(self, *args): return _mmut.Loop_GetString(self, *args)
    def CopyString(self, *args): return _mmut.Loop_CopyString(self, *args)
    def DeleteField(self, *args): return _mmut.Loop_DeleteField(self, *args)
    def DeleteRow(self, *args): return _mmut.Loop_DeleteRow(self, *args)
    def GetReal(self, *args): return _mmut.Loop_GetReal(self, *args)
    def CopyReal(self, *args): return _mmut.Loop_CopyReal(self, *args)
    def CopyInteger(self, *args): return _mmut.Loop_CopyInteger(self, *args)
    def GetInteger(self, *args): return _mmut.Loop_GetInteger(self, *args)
    def GetSVector(self, *args): return _mmut.Loop_GetSVector(self, *args)
    def GetRVector(self, *args): return _mmut.Loop_GetRVector(self, *args)
    def GetIVector(self, *args): return _mmut.Loop_GetIVector(self, *args)
    def PutString(self, *args): return _mmut.Loop_PutString(self, *args)
    def PutNoData(self, *args): return _mmut.Loop_PutNoData(self, *args)
    def PutReal(self, *args): return _mmut.Loop_PutReal(self, *args)
    def PutInteger(self, *args): return _mmut.Loop_PutInteger(self, *args)
    def PutSVector(self, *args): return _mmut.Loop_PutSVector(self, *args)
    def PutRVector(self, *args): return _mmut.Loop_PutRVector(self, *args)
    def PutIVector(self, *args): return _mmut.Loop_PutIVector(self, *args)
    def GetCategoryID(self): return _mmut.Loop_GetCategoryID(self)
    def Optimize(self): return _mmut.Loop_Optimize(self)
    def WriteMMCIFLoop(self, *args): return _mmut.Loop_WriteMMCIFLoop(self, *args)
    def Copy(self, *args): return _mmut.Loop_Copy(self, *args)
Loop_swigregister = _mmut.Loop_swigregister
Loop_swigregister(Loop)

CIFW_UnrecognizedItems = _mmut.CIFW_UnrecognizedItems
CIFW_MissingField = _mmut.CIFW_MissingField
CIFW_EmptyLoop = _mmut.CIFW_EmptyLoop
CIFW_UnexpectedEOF = _mmut.CIFW_UnexpectedEOF
CIFW_LoopFieldMissing = _mmut.CIFW_LoopFieldMissing
CIFW_NotAStructure = _mmut.CIFW_NotAStructure
CIFW_NotALoop = _mmut.CIFW_NotALoop
CIFW_DuplicateTag = _mmut.CIFW_DuplicateTag
CIFRC_Loop = _mmut.CIFRC_Loop
CIFRC_Structure = _mmut.CIFRC_Structure
CIFRC_Ok = _mmut.CIFRC_Ok
CIFRC_StructureNoTag = _mmut.CIFRC_StructureNoTag
CIFRC_LoopNoTag = _mmut.CIFRC_LoopNoTag
CIFRC_NoCategory = _mmut.CIFRC_NoCategory
CIFRC_WrongFormat = _mmut.CIFRC_WrongFormat
CIFRC_NoTag = _mmut.CIFRC_NoTag
CIFRC_NotAStructure = _mmut.CIFRC_NotAStructure
CIFRC_NotALoop = _mmut.CIFRC_NotALoop
CIFRC_WrongIndex = _mmut.CIFRC_WrongIndex
CIFRC_NoField = _mmut.CIFRC_NoField
CIFRC_Created = _mmut.CIFRC_Created
CIFRC_CantOpenFile = _mmut.CIFRC_CantOpenFile
CIFRC_NoDataLine = _mmut.CIFRC_NoDataLine
CIFRC_NoData = _mmut.CIFRC_NoData
CIFFL_PrintWarnings = _mmut.CIFFL_PrintWarnings
CIFFL_StopOnWarnings = _mmut.CIFFL_StopOnWarnings
CIFFL_SuggestCategories = _mmut.CIFFL_SuggestCategories
CIFFL_SuggestTags = _mmut.CIFFL_SuggestTags
class Data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Data, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Data(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Data
    __del__ = lambda self : None;
    def SetPrintWarnings(self, *args): return _mmut.Data_SetPrintWarnings(self, *args)
    def SetStopOnWarning(self, *args): return _mmut.Data_SetStopOnWarning(self, *args)
    def SetFlag(self, *args): return _mmut.Data_SetFlag(self, *args)
    def RemoveFlag(self, *args): return _mmut.Data_RemoveFlag(self, *args)
    def GetWarnings(self): return _mmut.Data_GetWarnings(self)
    def SetWrongFields(self, *args): return _mmut.Data_SetWrongFields(self, *args)
    def ReadMMCIFData(self, *args): return _mmut.Data_ReadMMCIFData(self, *args)
    def WriteMMCIFData(self, *args): return _mmut.Data_WriteMMCIFData(self, *args)
    def GetNumberOfCategories(self): return _mmut.Data_GetNumberOfCategories(self)
    def GetCategory(self, *args): return _mmut.Data_GetCategory(self, *args)
    def GetStructure(self, *args): return _mmut.Data_GetStructure(self, *args)
    def GetLoop(self, *args): return _mmut.Data_GetLoop(self, *args)
    def FindLoop(self, *args): return _mmut.Data_FindLoop(self, *args)
    def GetDataName(self, *args): return _mmut.Data_GetDataName(self, *args)
    def CheckData(self, *args): return _mmut.Data_CheckData(self, *args)
    def DeleteCategory(self, *args): return _mmut.Data_DeleteCategory(self, *args)
    def DeleteStructure(self, *args): return _mmut.Data_DeleteStructure(self, *args)
    def DeleteLoop(self, *args): return _mmut.Data_DeleteLoop(self, *args)
    def Optimize(self): return _mmut.Data_Optimize(self)
    def GetString(self, *args): return _mmut.Data_GetString(self, *args)
    def DeleteField(self, *args): return _mmut.Data_DeleteField(self, *args)
    def GetReal(self, *args): return _mmut.Data_GetReal(self, *args)
    def GetInteger(self, *args): return _mmut.Data_GetInteger(self, *args)
    def GetLoopLength(self, *args): return _mmut.Data_GetLoopLength(self, *args)
    def GetLoopString(self, *args): return _mmut.Data_GetLoopString(self, *args)
    def DeleteLoopField(self, *args): return _mmut.Data_DeleteLoopField(self, *args)
    def GetLoopReal(self, *args): return _mmut.Data_GetLoopReal(self, *args)
    def GetLoopInteger(self, *args): return _mmut.Data_GetLoopInteger(self, *args)
    def GetLoopSVector(self, *args): return _mmut.Data_GetLoopSVector(self, *args)
    def GetLoopRVector(self, *args): return _mmut.Data_GetLoopRVector(self, *args)
    def GetLoopIVector(self, *args): return _mmut.Data_GetLoopIVector(self, *args)
    def FreeMemory(self, *args): return _mmut.Data_FreeMemory(self, *args)
    def PutDataName(self, *args): return _mmut.Data_PutDataName(self, *args)
    def PutNoData(self, *args): return _mmut.Data_PutNoData(self, *args)
    def PutString(self, *args): return _mmut.Data_PutString(self, *args)
    def PutDate(self, *args): return _mmut.Data_PutDate(self, *args)
    def PutReal(self, *args): return _mmut.Data_PutReal(self, *args)
    def PutInteger(self, *args): return _mmut.Data_PutInteger(self, *args)
    def AddLoop(self, *args): return _mmut.Data_AddLoop(self, *args)
    def AddStructure(self, *args): return _mmut.Data_AddStructure(self, *args)
    def PutLoopNoData(self, *args): return _mmut.Data_PutLoopNoData(self, *args)
    def PutLoopString(self, *args): return _mmut.Data_PutLoopString(self, *args)
    def PutLoopReal(self, *args): return _mmut.Data_PutLoopReal(self, *args)
    def PutLoopInteger(self, *args): return _mmut.Data_PutLoopInteger(self, *args)
    def PutLoopSVector(self, *args): return _mmut.Data_PutLoopSVector(self, *args)
    def PutLoopRVector(self, *args): return _mmut.Data_PutLoopRVector(self, *args)
    def PutLoopIVector(self, *args): return _mmut.Data_PutLoopIVector(self, *args)
    def RenameCategory(self, *args): return _mmut.Data_RenameCategory(self, *args)
    def Copy(self, *args): return _mmut.Data_Copy(self, *args)
    def CopyCategory(self, *args): return _mmut.Data_CopyCategory(self, *args)
    def PrintCategories(self): return _mmut.Data_PrintCategories(self)
Data_swigregister = _mmut.Data_swigregister
Data_swigregister(Data)

class File(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, File, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, File, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nData"] = _mmut.File_nData_set
    __swig_getmethods__["nData"] = _mmut.File_nData_get
    if _newclass:nData = _swig_property(_mmut.File_nData_get, _mmut.File_nData_set)
    __swig_setmethods__["index"] = _mmut.File_index_set
    __swig_getmethods__["index"] = _mmut.File_index_get
    if _newclass:index = _swig_property(_mmut.File_index_get, _mmut.File_index_set)
    __swig_setmethods__["data"] = _mmut.File_data_set
    __swig_getmethods__["data"] = _mmut.File_data_get
    if _newclass:data = _swig_property(_mmut.File_data_get, _mmut.File_data_set)
    def __init__(self, *args): 
        this = _mmut.new_File(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_File
    __del__ = lambda self : None;
    def SetPrintWarnings(self, *args): return _mmut.File_SetPrintWarnings(self, *args)
    def SetStopOnWarning(self, *args): return _mmut.File_SetStopOnWarning(self, *args)
    def ReadMMCIFFile(self, *args): return _mmut.File_ReadMMCIFFile(self, *args)
    def WriteMMCIFFile(self, *args): return _mmut.File_WriteMMCIFFile(self, *args)
    def GetNofData(self): return _mmut.File_GetNofData(self)
    def GetCIFData(self, *args): return _mmut.File_GetCIFData(self, *args)
    def AddCIFData(self, *args): return _mmut.File_AddCIFData(self, *args)
    def DeleteCIFData(self, *args): return _mmut.File_DeleteCIFData(self, *args)
    def GetCIFDataNo(self, *args): return _mmut.File_GetCIFDataNo(self, *args)
    def Copy(self, *args): return _mmut.File_Copy(self, *args)
File_swigregister = _mmut.File_swigregister
File_swigregister(File)


def GetMMCIFInputBuffer(*args):
  return _mmut.GetMMCIFInputBuffer(*args)
GetMMCIFInputBuffer = _mmut.GetMMCIFInputBuffer

def isCIF(*args):
  return _mmut.isCIF(*args)
isCIF = _mmut.isCIF

def GetCIFMessage(*args):
  return _mmut.GetCIFMessage(*args)
GetCIFMessage = _mmut.GetCIFMessage
class HetCompound(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HetCompound, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HetCompound, name)
    __repr__ = _swig_repr
    __swig_setmethods__["hetID"] = _mmut.HetCompound_hetID_set
    __swig_getmethods__["hetID"] = _mmut.HetCompound_hetID_get
    if _newclass:hetID = _swig_property(_mmut.HetCompound_hetID_get, _mmut.HetCompound_hetID_set)
    __swig_setmethods__["comment"] = _mmut.HetCompound_comment_set
    __swig_getmethods__["comment"] = _mmut.HetCompound_comment_get
    if _newclass:comment = _swig_property(_mmut.HetCompound_comment_get, _mmut.HetCompound_comment_set)
    __swig_setmethods__["nSynonyms"] = _mmut.HetCompound_nSynonyms_set
    __swig_getmethods__["nSynonyms"] = _mmut.HetCompound_nSynonyms_get
    if _newclass:nSynonyms = _swig_property(_mmut.HetCompound_nSynonyms_get, _mmut.HetCompound_nSynonyms_set)
    __swig_setmethods__["hetSynonym"] = _mmut.HetCompound_hetSynonym_set
    __swig_getmethods__["hetSynonym"] = _mmut.HetCompound_hetSynonym_get
    if _newclass:hetSynonym = _swig_property(_mmut.HetCompound_hetSynonym_get, _mmut.HetCompound_hetSynonym_set)
    __swig_setmethods__["compNum"] = _mmut.HetCompound_compNum_set
    __swig_getmethods__["compNum"] = _mmut.HetCompound_compNum_get
    if _newclass:compNum = _swig_property(_mmut.HetCompound_compNum_get, _mmut.HetCompound_compNum_set)
    __swig_setmethods__["wc"] = _mmut.HetCompound_wc_set
    __swig_getmethods__["wc"] = _mmut.HetCompound_wc_get
    if _newclass:wc = _swig_property(_mmut.HetCompound_wc_get, _mmut.HetCompound_wc_set)
    __swig_setmethods__["Formula"] = _mmut.HetCompound_Formula_set
    __swig_getmethods__["Formula"] = _mmut.HetCompound_Formula_get
    if _newclass:Formula = _swig_property(_mmut.HetCompound_Formula_get, _mmut.HetCompound_Formula_set)
    def __init__(self, *args): 
        this = _mmut.new_HetCompound(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_HetCompound
    __del__ = lambda self : None;
    def AddKeyWord(self, *args): return _mmut.HetCompound_AddKeyWord(self, *args)
    def FormComString(self, *args): return _mmut.HetCompound_FormComString(self, *args)
    def FormSynString(self, *args): return _mmut.HetCompound_FormSynString(self, *args)
    def FormForString(self, *args): return _mmut.HetCompound_FormForString(self, *args)
    def Copy(self, *args): return _mmut.HetCompound_Copy(self, *args)
HetCompound_swigregister = _mmut.HetCompound_swigregister
HetCompound_swigregister(HetCompound)

class SSContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SSContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SSContainer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_SSContainer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_SSContainer
    __del__ = lambda self : None;
SSContainer_swigregister = _mmut.SSContainer_swigregister
SSContainer_swigregister(SSContainer)

class Helix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Helix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Helix, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serNum"] = _mmut.Helix_serNum_set
    __swig_getmethods__["serNum"] = _mmut.Helix_serNum_get
    if _newclass:serNum = _swig_property(_mmut.Helix_serNum_get, _mmut.Helix_serNum_set)
    __swig_setmethods__["helixID"] = _mmut.Helix_helixID_set
    __swig_getmethods__["helixID"] = _mmut.Helix_helixID_get
    if _newclass:helixID = _swig_property(_mmut.Helix_helixID_get, _mmut.Helix_helixID_set)
    __swig_setmethods__["initResName"] = _mmut.Helix_initResName_set
    __swig_getmethods__["initResName"] = _mmut.Helix_initResName_get
    if _newclass:initResName = _swig_property(_mmut.Helix_initResName_get, _mmut.Helix_initResName_set)
    __swig_setmethods__["initChainID"] = _mmut.Helix_initChainID_set
    __swig_getmethods__["initChainID"] = _mmut.Helix_initChainID_get
    if _newclass:initChainID = _swig_property(_mmut.Helix_initChainID_get, _mmut.Helix_initChainID_set)
    __swig_setmethods__["initSeqNum"] = _mmut.Helix_initSeqNum_set
    __swig_getmethods__["initSeqNum"] = _mmut.Helix_initSeqNum_get
    if _newclass:initSeqNum = _swig_property(_mmut.Helix_initSeqNum_get, _mmut.Helix_initSeqNum_set)
    __swig_setmethods__["initICode"] = _mmut.Helix_initICode_set
    __swig_getmethods__["initICode"] = _mmut.Helix_initICode_get
    if _newclass:initICode = _swig_property(_mmut.Helix_initICode_get, _mmut.Helix_initICode_set)
    __swig_setmethods__["endResName"] = _mmut.Helix_endResName_set
    __swig_getmethods__["endResName"] = _mmut.Helix_endResName_get
    if _newclass:endResName = _swig_property(_mmut.Helix_endResName_get, _mmut.Helix_endResName_set)
    __swig_setmethods__["endChainID"] = _mmut.Helix_endChainID_set
    __swig_getmethods__["endChainID"] = _mmut.Helix_endChainID_get
    if _newclass:endChainID = _swig_property(_mmut.Helix_endChainID_get, _mmut.Helix_endChainID_set)
    __swig_setmethods__["endSeqNum"] = _mmut.Helix_endSeqNum_set
    __swig_getmethods__["endSeqNum"] = _mmut.Helix_endSeqNum_get
    if _newclass:endSeqNum = _swig_property(_mmut.Helix_endSeqNum_get, _mmut.Helix_endSeqNum_set)
    __swig_setmethods__["endICode"] = _mmut.Helix_endICode_set
    __swig_getmethods__["endICode"] = _mmut.Helix_endICode_get
    if _newclass:endICode = _swig_property(_mmut.Helix_endICode_get, _mmut.Helix_endICode_set)
    __swig_setmethods__["helixClass"] = _mmut.Helix_helixClass_set
    __swig_getmethods__["helixClass"] = _mmut.Helix_helixClass_get
    if _newclass:helixClass = _swig_property(_mmut.Helix_helixClass_get, _mmut.Helix_helixClass_set)
    __swig_setmethods__["comment"] = _mmut.Helix_comment_set
    __swig_getmethods__["comment"] = _mmut.Helix_comment_get
    if _newclass:comment = _swig_property(_mmut.Helix_comment_get, _mmut.Helix_comment_set)
    __swig_setmethods__["length"] = _mmut.Helix_length_set
    __swig_getmethods__["length"] = _mmut.Helix_length_get
    if _newclass:length = _swig_property(_mmut.Helix_length_get, _mmut.Helix_length_set)
    def __init__(self, *args): 
        this = _mmut.new_Helix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Helix
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.Helix_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Helix_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Helix_GetCIF(self, *args)
    def GetClassID(self): return _mmut.Helix_GetClassID(self)
    def Copy(self, *args): return _mmut.Helix_Copy(self, *args)
Helix_swigregister = _mmut.Helix_swigregister
Helix_swigregister(Helix)

class Strand(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Strand, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Strand, name)
    __repr__ = _swig_repr
    __swig_setmethods__["sheetID"] = _mmut.Strand_sheetID_set
    __swig_getmethods__["sheetID"] = _mmut.Strand_sheetID_get
    if _newclass:sheetID = _swig_property(_mmut.Strand_sheetID_get, _mmut.Strand_sheetID_set)
    __swig_setmethods__["strandNo"] = _mmut.Strand_strandNo_set
    __swig_getmethods__["strandNo"] = _mmut.Strand_strandNo_get
    if _newclass:strandNo = _swig_property(_mmut.Strand_strandNo_get, _mmut.Strand_strandNo_set)
    __swig_setmethods__["initResName"] = _mmut.Strand_initResName_set
    __swig_getmethods__["initResName"] = _mmut.Strand_initResName_get
    if _newclass:initResName = _swig_property(_mmut.Strand_initResName_get, _mmut.Strand_initResName_set)
    __swig_setmethods__["initChainID"] = _mmut.Strand_initChainID_set
    __swig_getmethods__["initChainID"] = _mmut.Strand_initChainID_get
    if _newclass:initChainID = _swig_property(_mmut.Strand_initChainID_get, _mmut.Strand_initChainID_set)
    __swig_setmethods__["initSeqNum"] = _mmut.Strand_initSeqNum_set
    __swig_getmethods__["initSeqNum"] = _mmut.Strand_initSeqNum_get
    if _newclass:initSeqNum = _swig_property(_mmut.Strand_initSeqNum_get, _mmut.Strand_initSeqNum_set)
    __swig_setmethods__["initICode"] = _mmut.Strand_initICode_set
    __swig_getmethods__["initICode"] = _mmut.Strand_initICode_get
    if _newclass:initICode = _swig_property(_mmut.Strand_initICode_get, _mmut.Strand_initICode_set)
    __swig_setmethods__["endResName"] = _mmut.Strand_endResName_set
    __swig_getmethods__["endResName"] = _mmut.Strand_endResName_get
    if _newclass:endResName = _swig_property(_mmut.Strand_endResName_get, _mmut.Strand_endResName_set)
    __swig_setmethods__["endChainID"] = _mmut.Strand_endChainID_set
    __swig_getmethods__["endChainID"] = _mmut.Strand_endChainID_get
    if _newclass:endChainID = _swig_property(_mmut.Strand_endChainID_get, _mmut.Strand_endChainID_set)
    __swig_setmethods__["endSeqNum"] = _mmut.Strand_endSeqNum_set
    __swig_getmethods__["endSeqNum"] = _mmut.Strand_endSeqNum_get
    if _newclass:endSeqNum = _swig_property(_mmut.Strand_endSeqNum_get, _mmut.Strand_endSeqNum_set)
    __swig_setmethods__["endICode"] = _mmut.Strand_endICode_set
    __swig_getmethods__["endICode"] = _mmut.Strand_endICode_get
    if _newclass:endICode = _swig_property(_mmut.Strand_endICode_get, _mmut.Strand_endICode_set)
    __swig_setmethods__["sense"] = _mmut.Strand_sense_set
    __swig_getmethods__["sense"] = _mmut.Strand_sense_get
    if _newclass:sense = _swig_property(_mmut.Strand_sense_get, _mmut.Strand_sense_set)
    __swig_setmethods__["curAtom"] = _mmut.Strand_curAtom_set
    __swig_getmethods__["curAtom"] = _mmut.Strand_curAtom_get
    if _newclass:curAtom = _swig_property(_mmut.Strand_curAtom_get, _mmut.Strand_curAtom_set)
    __swig_setmethods__["curResName"] = _mmut.Strand_curResName_set
    __swig_getmethods__["curResName"] = _mmut.Strand_curResName_get
    if _newclass:curResName = _swig_property(_mmut.Strand_curResName_get, _mmut.Strand_curResName_set)
    __swig_setmethods__["curChainID"] = _mmut.Strand_curChainID_set
    __swig_getmethods__["curChainID"] = _mmut.Strand_curChainID_get
    if _newclass:curChainID = _swig_property(_mmut.Strand_curChainID_get, _mmut.Strand_curChainID_set)
    __swig_setmethods__["curResSeq"] = _mmut.Strand_curResSeq_set
    __swig_getmethods__["curResSeq"] = _mmut.Strand_curResSeq_get
    if _newclass:curResSeq = _swig_property(_mmut.Strand_curResSeq_get, _mmut.Strand_curResSeq_set)
    __swig_setmethods__["curICode"] = _mmut.Strand_curICode_set
    __swig_getmethods__["curICode"] = _mmut.Strand_curICode_get
    if _newclass:curICode = _swig_property(_mmut.Strand_curICode_get, _mmut.Strand_curICode_set)
    __swig_setmethods__["prevAtom"] = _mmut.Strand_prevAtom_set
    __swig_getmethods__["prevAtom"] = _mmut.Strand_prevAtom_get
    if _newclass:prevAtom = _swig_property(_mmut.Strand_prevAtom_get, _mmut.Strand_prevAtom_set)
    __swig_setmethods__["prevResName"] = _mmut.Strand_prevResName_set
    __swig_getmethods__["prevResName"] = _mmut.Strand_prevResName_get
    if _newclass:prevResName = _swig_property(_mmut.Strand_prevResName_get, _mmut.Strand_prevResName_set)
    __swig_setmethods__["prevChainID"] = _mmut.Strand_prevChainID_set
    __swig_getmethods__["prevChainID"] = _mmut.Strand_prevChainID_get
    if _newclass:prevChainID = _swig_property(_mmut.Strand_prevChainID_get, _mmut.Strand_prevChainID_set)
    __swig_setmethods__["prevResSeq"] = _mmut.Strand_prevResSeq_set
    __swig_getmethods__["prevResSeq"] = _mmut.Strand_prevResSeq_get
    if _newclass:prevResSeq = _swig_property(_mmut.Strand_prevResSeq_get, _mmut.Strand_prevResSeq_set)
    __swig_setmethods__["prevICode"] = _mmut.Strand_prevICode_set
    __swig_getmethods__["prevICode"] = _mmut.Strand_prevICode_get
    if _newclass:prevICode = _swig_property(_mmut.Strand_prevICode_get, _mmut.Strand_prevICode_set)
    def __init__(self): 
        this = _mmut.new_Strand()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Strand
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.Strand_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Strand_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Strand_GetCIF(self, *args)
    def Copy(self, *args): return _mmut.Strand_Copy(self, *args)
Strand_swigregister = _mmut.Strand_swigregister
Strand_swigregister(Strand)

class Sheet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sheet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Sheet, name)
    __repr__ = _swig_repr
    __swig_setmethods__["sheetID"] = _mmut.Sheet_sheetID_set
    __swig_getmethods__["sheetID"] = _mmut.Sheet_sheetID_get
    if _newclass:sheetID = _swig_property(_mmut.Sheet_sheetID_get, _mmut.Sheet_sheetID_set)
    __swig_setmethods__["nStrands"] = _mmut.Sheet_nStrands_set
    __swig_getmethods__["nStrands"] = _mmut.Sheet_nStrands_get
    if _newclass:nStrands = _swig_property(_mmut.Sheet_nStrands_get, _mmut.Sheet_nStrands_set)
    __swig_setmethods__["strand"] = _mmut.Sheet_strand_set
    __swig_getmethods__["strand"] = _mmut.Sheet_strand_get
    if _newclass:strand = _swig_property(_mmut.Sheet_strand_get, _mmut.Sheet_strand_set)
    def __init__(self): 
        this = _mmut.new_Sheet()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Sheet
    __del__ = lambda self : None;
    def FreeMemory(self): return _mmut.Sheet_FreeMemory(self)
    def OrderSheet(self): return _mmut.Sheet_OrderSheet(self)
    def MakeCIF(self, *args): return _mmut.Sheet_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Sheet_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Sheet_GetCIF(self, *args)
    def Copy(self, *args): return _mmut.Sheet_Copy(self, *args)
Sheet_swigregister = _mmut.Sheet_swigregister
Sheet_swigregister(Sheet)

class Sheets(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sheets, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Sheets, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nSheets"] = _mmut.Sheets_nSheets_set
    __swig_getmethods__["nSheets"] = _mmut.Sheets_nSheets_get
    if _newclass:nSheets = _swig_property(_mmut.Sheets_nSheets_get, _mmut.Sheets_nSheets_set)
    __swig_setmethods__["sheet"] = _mmut.Sheets_sheet_set
    __swig_getmethods__["sheet"] = _mmut.Sheets_sheet_get
    if _newclass:sheet = _swig_property(_mmut.Sheets_sheet_get, _mmut.Sheets_sheet_set)
    def __init__(self): 
        this = _mmut.new_Sheets()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Sheets
    __del__ = lambda self : None;
    def FreeMemory(self): return _mmut.Sheets_FreeMemory(self)
    def MakeCIF(self, *args): return _mmut.Sheets_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Sheets_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Sheets_GetCIF(self, *args)
    def Copy(self, *args): return _mmut.Sheets_Copy(self, *args)
Sheets_swigregister = _mmut.Sheets_swigregister
Sheets_swigregister(Sheets)

class Turn(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Turn, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Turn, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serNum"] = _mmut.Turn_serNum_set
    __swig_getmethods__["serNum"] = _mmut.Turn_serNum_get
    if _newclass:serNum = _swig_property(_mmut.Turn_serNum_get, _mmut.Turn_serNum_set)
    __swig_setmethods__["turnID"] = _mmut.Turn_turnID_set
    __swig_getmethods__["turnID"] = _mmut.Turn_turnID_get
    if _newclass:turnID = _swig_property(_mmut.Turn_turnID_get, _mmut.Turn_turnID_set)
    __swig_setmethods__["initResName"] = _mmut.Turn_initResName_set
    __swig_getmethods__["initResName"] = _mmut.Turn_initResName_get
    if _newclass:initResName = _swig_property(_mmut.Turn_initResName_get, _mmut.Turn_initResName_set)
    __swig_setmethods__["initChainID"] = _mmut.Turn_initChainID_set
    __swig_getmethods__["initChainID"] = _mmut.Turn_initChainID_get
    if _newclass:initChainID = _swig_property(_mmut.Turn_initChainID_get, _mmut.Turn_initChainID_set)
    __swig_setmethods__["initSeqNum"] = _mmut.Turn_initSeqNum_set
    __swig_getmethods__["initSeqNum"] = _mmut.Turn_initSeqNum_get
    if _newclass:initSeqNum = _swig_property(_mmut.Turn_initSeqNum_get, _mmut.Turn_initSeqNum_set)
    __swig_setmethods__["initICode"] = _mmut.Turn_initICode_set
    __swig_getmethods__["initICode"] = _mmut.Turn_initICode_get
    if _newclass:initICode = _swig_property(_mmut.Turn_initICode_get, _mmut.Turn_initICode_set)
    __swig_setmethods__["endResName"] = _mmut.Turn_endResName_set
    __swig_getmethods__["endResName"] = _mmut.Turn_endResName_get
    if _newclass:endResName = _swig_property(_mmut.Turn_endResName_get, _mmut.Turn_endResName_set)
    __swig_setmethods__["endChainID"] = _mmut.Turn_endChainID_set
    __swig_getmethods__["endChainID"] = _mmut.Turn_endChainID_get
    if _newclass:endChainID = _swig_property(_mmut.Turn_endChainID_get, _mmut.Turn_endChainID_set)
    __swig_setmethods__["endSeqNum"] = _mmut.Turn_endSeqNum_set
    __swig_getmethods__["endSeqNum"] = _mmut.Turn_endSeqNum_get
    if _newclass:endSeqNum = _swig_property(_mmut.Turn_endSeqNum_get, _mmut.Turn_endSeqNum_set)
    __swig_setmethods__["endICode"] = _mmut.Turn_endICode_set
    __swig_getmethods__["endICode"] = _mmut.Turn_endICode_get
    if _newclass:endICode = _swig_property(_mmut.Turn_endICode_get, _mmut.Turn_endICode_set)
    __swig_setmethods__["comment"] = _mmut.Turn_comment_set
    __swig_getmethods__["comment"] = _mmut.Turn_comment_get
    if _newclass:comment = _swig_property(_mmut.Turn_comment_get, _mmut.Turn_comment_set)
    def __init__(self, *args): 
        this = _mmut.new_Turn(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Turn
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.Turn_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Turn_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Turn_GetCIF(self, *args)
    def GetClassID(self): return _mmut.Turn_GetClassID(self)
    def Copy(self, *args): return _mmut.Turn_Copy(self, *args)
Turn_swigregister = _mmut.Turn_swigregister
Turn_swigregister(Turn)

class HetCompounds(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HetCompounds, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HetCompounds, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nHets"] = _mmut.HetCompounds_nHets_set
    __swig_getmethods__["nHets"] = _mmut.HetCompounds_nHets_get
    if _newclass:nHets = _swig_property(_mmut.HetCompounds_nHets_get, _mmut.HetCompounds_nHets_set)
    __swig_setmethods__["hetCompound"] = _mmut.HetCompounds_hetCompound_set
    __swig_getmethods__["hetCompound"] = _mmut.HetCompounds_hetCompound_get
    if _newclass:hetCompound = _swig_property(_mmut.HetCompounds_hetCompound_get, _mmut.HetCompounds_hetCompound_set)
    def __init__(self): 
        this = _mmut.new_HetCompounds()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_HetCompounds
    __del__ = lambda self : None;
    def FreeMemory(self): return _mmut.HetCompounds_FreeMemory(self)
    def ConvertHETNAM(self, *args): return _mmut.HetCompounds_ConvertHETNAM(self, *args)
    def ConvertHETSYN(self, *args): return _mmut.HetCompounds_ConvertHETSYN(self, *args)
    def ConvertFORMUL(self, *args): return _mmut.HetCompounds_ConvertFORMUL(self, *args)
    def MakeCIF(self, *args): return _mmut.HetCompounds_MakeCIF(self, *args)
    def GetCIF(self, *args): return _mmut.HetCompounds_GetCIF(self, *args)
    def Copy(self, *args): return _mmut.HetCompounds_Copy(self, *args)
HetCompounds_swigregister = _mmut.HetCompounds_swigregister
HetCompounds_swigregister(HetCompounds)

class LinkContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinkContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinkContainer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_LinkContainer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_LinkContainer
    __del__ = lambda self : None;
LinkContainer_swigregister = _mmut.LinkContainer_swigregister
LinkContainer_swigregister(LinkContainer)

class Link(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Link, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Link, name)
    __repr__ = _swig_repr
    __swig_setmethods__["atName1"] = _mmut.Link_atName1_set
    __swig_getmethods__["atName1"] = _mmut.Link_atName1_get
    if _newclass:atName1 = _swig_property(_mmut.Link_atName1_get, _mmut.Link_atName1_set)
    __swig_setmethods__["aloc1"] = _mmut.Link_aloc1_set
    __swig_getmethods__["aloc1"] = _mmut.Link_aloc1_get
    if _newclass:aloc1 = _swig_property(_mmut.Link_aloc1_get, _mmut.Link_aloc1_set)
    __swig_setmethods__["resName1"] = _mmut.Link_resName1_set
    __swig_getmethods__["resName1"] = _mmut.Link_resName1_get
    if _newclass:resName1 = _swig_property(_mmut.Link_resName1_get, _mmut.Link_resName1_set)
    __swig_setmethods__["chainID1"] = _mmut.Link_chainID1_set
    __swig_getmethods__["chainID1"] = _mmut.Link_chainID1_get
    if _newclass:chainID1 = _swig_property(_mmut.Link_chainID1_get, _mmut.Link_chainID1_set)
    __swig_setmethods__["seqNum1"] = _mmut.Link_seqNum1_set
    __swig_getmethods__["seqNum1"] = _mmut.Link_seqNum1_get
    if _newclass:seqNum1 = _swig_property(_mmut.Link_seqNum1_get, _mmut.Link_seqNum1_set)
    __swig_setmethods__["insCode1"] = _mmut.Link_insCode1_set
    __swig_getmethods__["insCode1"] = _mmut.Link_insCode1_get
    if _newclass:insCode1 = _swig_property(_mmut.Link_insCode1_get, _mmut.Link_insCode1_set)
    __swig_setmethods__["atName2"] = _mmut.Link_atName2_set
    __swig_getmethods__["atName2"] = _mmut.Link_atName2_get
    if _newclass:atName2 = _swig_property(_mmut.Link_atName2_get, _mmut.Link_atName2_set)
    __swig_setmethods__["aloc2"] = _mmut.Link_aloc2_set
    __swig_getmethods__["aloc2"] = _mmut.Link_aloc2_get
    if _newclass:aloc2 = _swig_property(_mmut.Link_aloc2_get, _mmut.Link_aloc2_set)
    __swig_setmethods__["resName2"] = _mmut.Link_resName2_set
    __swig_getmethods__["resName2"] = _mmut.Link_resName2_get
    if _newclass:resName2 = _swig_property(_mmut.Link_resName2_get, _mmut.Link_resName2_set)
    __swig_setmethods__["chainID2"] = _mmut.Link_chainID2_set
    __swig_getmethods__["chainID2"] = _mmut.Link_chainID2_get
    if _newclass:chainID2 = _swig_property(_mmut.Link_chainID2_get, _mmut.Link_chainID2_set)
    __swig_setmethods__["seqNum2"] = _mmut.Link_seqNum2_set
    __swig_getmethods__["seqNum2"] = _mmut.Link_seqNum2_get
    if _newclass:seqNum2 = _swig_property(_mmut.Link_seqNum2_get, _mmut.Link_seqNum2_set)
    __swig_setmethods__["insCode2"] = _mmut.Link_insCode2_set
    __swig_getmethods__["insCode2"] = _mmut.Link_insCode2_get
    if _newclass:insCode2 = _swig_property(_mmut.Link_insCode2_get, _mmut.Link_insCode2_set)
    __swig_setmethods__["s1"] = _mmut.Link_s1_set
    __swig_getmethods__["s1"] = _mmut.Link_s1_get
    if _newclass:s1 = _swig_property(_mmut.Link_s1_get, _mmut.Link_s1_set)
    __swig_setmethods__["i1"] = _mmut.Link_i1_set
    __swig_getmethods__["i1"] = _mmut.Link_i1_get
    if _newclass:i1 = _swig_property(_mmut.Link_i1_get, _mmut.Link_i1_set)
    __swig_setmethods__["j1"] = _mmut.Link_j1_set
    __swig_getmethods__["j1"] = _mmut.Link_j1_get
    if _newclass:j1 = _swig_property(_mmut.Link_j1_get, _mmut.Link_j1_set)
    __swig_setmethods__["k1"] = _mmut.Link_k1_set
    __swig_getmethods__["k1"] = _mmut.Link_k1_get
    if _newclass:k1 = _swig_property(_mmut.Link_k1_get, _mmut.Link_k1_set)
    __swig_setmethods__["s2"] = _mmut.Link_s2_set
    __swig_getmethods__["s2"] = _mmut.Link_s2_get
    if _newclass:s2 = _swig_property(_mmut.Link_s2_get, _mmut.Link_s2_set)
    __swig_setmethods__["i2"] = _mmut.Link_i2_set
    __swig_getmethods__["i2"] = _mmut.Link_i2_get
    if _newclass:i2 = _swig_property(_mmut.Link_i2_get, _mmut.Link_i2_set)
    __swig_setmethods__["j2"] = _mmut.Link_j2_set
    __swig_getmethods__["j2"] = _mmut.Link_j2_get
    if _newclass:j2 = _swig_property(_mmut.Link_j2_get, _mmut.Link_j2_set)
    __swig_setmethods__["k2"] = _mmut.Link_k2_set
    __swig_getmethods__["k2"] = _mmut.Link_k2_get
    if _newclass:k2 = _swig_property(_mmut.Link_k2_get, _mmut.Link_k2_set)
    def __init__(self, *args): 
        this = _mmut.new_Link(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Link
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.Link_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.Link_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.Link_GetCIF(self, *args)
    def GetClassID(self): return _mmut.Link_GetClassID(self)
    def Copy(self, *args): return _mmut.Link_Copy(self, *args)
Link_swigregister = _mmut.Link_swigregister
Link_swigregister(Link)

class LinkRContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinkRContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinkRContainer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_LinkRContainer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_LinkRContainer
    __del__ = lambda self : None;
LinkRContainer_swigregister = _mmut.LinkRContainer_swigregister
LinkRContainer_swigregister(LinkRContainer)

class LinkR(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinkR, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinkR, name)
    __repr__ = _swig_repr
    __swig_setmethods__["linkRID"] = _mmut.LinkR_linkRID_set
    __swig_getmethods__["linkRID"] = _mmut.LinkR_linkRID_get
    if _newclass:linkRID = _swig_property(_mmut.LinkR_linkRID_get, _mmut.LinkR_linkRID_set)
    __swig_setmethods__["atName1"] = _mmut.LinkR_atName1_set
    __swig_getmethods__["atName1"] = _mmut.LinkR_atName1_get
    if _newclass:atName1 = _swig_property(_mmut.LinkR_atName1_get, _mmut.LinkR_atName1_set)
    __swig_setmethods__["aloc1"] = _mmut.LinkR_aloc1_set
    __swig_getmethods__["aloc1"] = _mmut.LinkR_aloc1_get
    if _newclass:aloc1 = _swig_property(_mmut.LinkR_aloc1_get, _mmut.LinkR_aloc1_set)
    __swig_setmethods__["resName1"] = _mmut.LinkR_resName1_set
    __swig_getmethods__["resName1"] = _mmut.LinkR_resName1_get
    if _newclass:resName1 = _swig_property(_mmut.LinkR_resName1_get, _mmut.LinkR_resName1_set)
    __swig_setmethods__["chainID1"] = _mmut.LinkR_chainID1_set
    __swig_getmethods__["chainID1"] = _mmut.LinkR_chainID1_get
    if _newclass:chainID1 = _swig_property(_mmut.LinkR_chainID1_get, _mmut.LinkR_chainID1_set)
    __swig_setmethods__["seqNum1"] = _mmut.LinkR_seqNum1_set
    __swig_getmethods__["seqNum1"] = _mmut.LinkR_seqNum1_get
    if _newclass:seqNum1 = _swig_property(_mmut.LinkR_seqNum1_get, _mmut.LinkR_seqNum1_set)
    __swig_setmethods__["insCode1"] = _mmut.LinkR_insCode1_set
    __swig_getmethods__["insCode1"] = _mmut.LinkR_insCode1_get
    if _newclass:insCode1 = _swig_property(_mmut.LinkR_insCode1_get, _mmut.LinkR_insCode1_set)
    __swig_setmethods__["atName2"] = _mmut.LinkR_atName2_set
    __swig_getmethods__["atName2"] = _mmut.LinkR_atName2_get
    if _newclass:atName2 = _swig_property(_mmut.LinkR_atName2_get, _mmut.LinkR_atName2_set)
    __swig_setmethods__["aloc2"] = _mmut.LinkR_aloc2_set
    __swig_getmethods__["aloc2"] = _mmut.LinkR_aloc2_get
    if _newclass:aloc2 = _swig_property(_mmut.LinkR_aloc2_get, _mmut.LinkR_aloc2_set)
    __swig_setmethods__["resName2"] = _mmut.LinkR_resName2_set
    __swig_getmethods__["resName2"] = _mmut.LinkR_resName2_get
    if _newclass:resName2 = _swig_property(_mmut.LinkR_resName2_get, _mmut.LinkR_resName2_set)
    __swig_setmethods__["chainID2"] = _mmut.LinkR_chainID2_set
    __swig_getmethods__["chainID2"] = _mmut.LinkR_chainID2_get
    if _newclass:chainID2 = _swig_property(_mmut.LinkR_chainID2_get, _mmut.LinkR_chainID2_set)
    __swig_setmethods__["seqNum2"] = _mmut.LinkR_seqNum2_set
    __swig_getmethods__["seqNum2"] = _mmut.LinkR_seqNum2_get
    if _newclass:seqNum2 = _swig_property(_mmut.LinkR_seqNum2_get, _mmut.LinkR_seqNum2_set)
    __swig_setmethods__["insCode2"] = _mmut.LinkR_insCode2_set
    __swig_getmethods__["insCode2"] = _mmut.LinkR_insCode2_get
    if _newclass:insCode2 = _swig_property(_mmut.LinkR_insCode2_get, _mmut.LinkR_insCode2_set)
    __swig_setmethods__["dist"] = _mmut.LinkR_dist_set
    __swig_getmethods__["dist"] = _mmut.LinkR_dist_get
    if _newclass:dist = _swig_property(_mmut.LinkR_dist_get, _mmut.LinkR_dist_set)
    def __init__(self, *args): 
        this = _mmut.new_LinkR(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_LinkR
    __del__ = lambda self : None;
    def MakeCIF(self, *args): return _mmut.LinkR_MakeCIF(self, *args)
    def ConvertPDBASCII(self, *args): return _mmut.LinkR_ConvertPDBASCII(self, *args)
    def GetCIF(self, *args): return _mmut.LinkR_GetCIF(self, *args)
    def GetClassID(self): return _mmut.LinkR_GetClassID(self)
    def Copy(self, *args): return _mmut.LinkR_Copy(self, *args)
LinkR_swigregister = _mmut.LinkR_swigregister
LinkR_swigregister(LinkR)

class CisPepContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CisPepContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CisPepContainer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_CisPepContainer()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CisPepContainer
    __del__ = lambda self : None;
CisPepContainer_swigregister = _mmut.CisPepContainer_swigregister
CisPepContainer_swigregister(CisPepContainer)

class CisPep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CisPep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CisPep, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serNum"] = _mmut.CisPep_serNum_set
    __swig_getmethods__["serNum"] = _mmut.CisPep_serNum_get
    if _newclass:serNum = _swig_property(_mmut.CisPep_serNum_get, _mmut.CisPep_serNum_set)
    __swig_setmethods__["pep1"] = _mmut.CisPep_pep1_set
    __swig_getmethods__["pep1"] = _mmut.CisPep_pep1_get
    if _newclass:pep1 = _swig_property(_mmut.CisPep_pep1_get, _mmut.CisPep_pep1_set)
    __swig_setmethods__["chainID1"] = _mmut.CisPep_chainID1_set
    __swig_getmethods__["chainID1"] = _mmut.CisPep_chainID1_get
    if _newclass:chainID1 = _swig_property(_mmut.CisPep_chainID1_get, _mmut.CisPep_chainID1_set)
    __swig_setmethods__["seqNum1"] = _mmut.CisPep_seqNum1_set
    __swig_getmethods__["seqNum1"] = _mmut.CisPep_seqNum1_get
    if _newclass:seqNum1 = _swig_property(_mmut.CisPep_seqNum1_get, _mmut.CisPep_seqNum1_set)
    __swig_setmethods__["icode1"] = _mmut.CisPep_icode1_set
    __swig_getmethods__["icode1"] = _mmut.CisPep_icode1_get
    if _newclass:icode1 = _swig_property(_mmut.CisPep_icode1_get, _mmut.CisPep_icode1_set)
    __swig_setmethods__["pep2"] = _mmut.CisPep_pep2_set
    __swig_getmethods__["pep2"] = _mmut.CisPep_pep2_get
    if _newclass:pep2 = _swig_property(_mmut.CisPep_pep2_get, _mmut.CisPep_pep2_set)
    __swig_setmethods__["chainID2"] = _mmut.CisPep_chainID2_set
    __swig_getmethods__["chainID2"] = _mmut.CisPep_chainID2_get
    if _newclass:chainID2 = _swig_property(_mmut.CisPep_chainID2_get, _mmut.CisPep_chainID2_set)
    __swig_setmethods__["seqNum2"] = _mmut.CisPep_seqNum2_set
    __swig_getmethods__["seqNum2"] = _mmut.CisPep_seqNum2_get
    if _newclass:seqNum2 = _swig_property(_mmut.CisPep_seqNum2_get, _mmut.CisPep_seqNum2_set)
    __swig_setmethods__["icode2"] = _mmut.CisPep_icode2_set
    __swig_getmethods__["icode2"] = _mmut.CisPep_icode2_get
    if _newclass:icode2 = _swig_property(_mmut.CisPep_icode2_get, _mmut.CisPep_icode2_set)
    __swig_setmethods__["modNum"] = _mmut.CisPep_modNum_set
    __swig_getmethods__["modNum"] = _mmut.CisPep_modNum_get
    if _newclass:modNum = _swig_property(_mmut.CisPep_modNum_get, _mmut.CisPep_modNum_set)
    __swig_setmethods__["measure"] = _mmut.CisPep_measure_set
    __swig_getmethods__["measure"] = _mmut.CisPep_measure_get
    if _newclass:measure = _swig_property(_mmut.CisPep_measure_get, _mmut.CisPep_measure_set)
    def __init__(self, *args): 
        this = _mmut.new_CisPep(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CisPep
    __del__ = lambda self : None;
    def ConvertPDBASCII(self, *args): return _mmut.CisPep_ConvertPDBASCII(self, *args)
    def GetClassID(self): return _mmut.CisPep_GetClassID(self)
    def Copy(self, *args): return _mmut.CisPep_Copy(self, *args)
CisPep_swigregister = _mmut.CisPep_swigregister
CisPep_swigregister(CisPep)

SSERC_Ok = _mmut.SSERC_Ok
SSERC_noResidues = _mmut.SSERC_noResidues
SSERC_noAminoacids = _mmut.SSERC_noAminoacids
SSERC_noSSE = _mmut.SSERC_noSSE
SORT_CHAIN_ChainID_Asc = _mmut.SORT_CHAIN_ChainID_Asc
SORT_CHAIN_ChainID_Desc = _mmut.SORT_CHAIN_ChainID_Desc

def newModel():
  return _mmut.newModel()
newModel = _mmut.newModel

def SetMakersModel(*args):
  return _mmut.SetMakersModel(*args)
SetMakersModel = _mmut.SetMakersModel
class Model(ProModel):
    __swig_setmethods__ = {}
    for _s in [ProModel]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    for _s in [ProModel]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_Model(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Model
    __del__ = lambda self : None;
    def SetMMDBManager(self, *args): return _mmut.Model_SetMMDBManager(self, *args)
    def GetCoordHierarchy(self): return _mmut.Model_GetCoordHierarchy(self)
    def GetChainCreate(self, *args): return _mmut.Model_GetChainCreate(self, *args)
    def CreateChain(self, *args): return _mmut.Model_CreateChain(self, *args)
    def GetEntryID(self): return _mmut.Model_GetEntryID(self)
    def SetEntryID(self, *args): return _mmut.Model_SetEntryID(self, *args)
    def GetSerNum(self): return _mmut.Model_GetSerNum(self)
    def GetModelID(self, *args): return _mmut.Model_GetModelID(self, *args)
    def GetNumberOfModels(self): return _mmut.Model_GetNumberOfModels(self)
    def GetNumberOfChains(self): return _mmut.Model_GetNumberOfChains(self)
    def GetNewChainID(self, *args): return _mmut.Model_GetNewChainID(self, *args)
    def GetChain(self, *args): return _mmut.Model_GetChain(self, *args)
    def GetChainTable(self, *args): return _mmut.Model_GetChainTable(self, *args)
    def DeleteChain(self, *args): return _mmut.Model_DeleteChain(self, *args)
    def DeleteAllChains(self): return _mmut.Model_DeleteAllChains(self)
    def DeleteSolventChains(self): return _mmut.Model_DeleteSolventChains(self)
    def TrimChainTable(self): return _mmut.Model_TrimChainTable(self)
    def AddChain(self, *args): return _mmut.Model_AddChain(self, *args)
    def SortChains(self, *args): return _mmut.Model_SortChains(self, *args)
    def GetNumberOfResidues(self, *args): return _mmut.Model_GetNumberOfResidues(self, *args)
    def GetResidue(self, *args): return _mmut.Model_GetResidue(self, *args)
    def GetResidueNo(self, *args): return _mmut.Model_GetResidueNo(self, *args)
    def GetResidueTable(self, *args): return _mmut.Model_GetResidueTable(self, *args)
    def DeleteResidue(self, *args): return _mmut.Model_DeleteResidue(self, *args)
    def DeleteSolvent(self): return _mmut.Model_DeleteSolvent(self)
    def DeleteAllResidues(self, *args): return _mmut.Model_DeleteAllResidues(self, *args)
    def AddResidue(self, *args): return _mmut.Model_AddResidue(self, *args)
    def GetNumberOfAllAtoms(self): return _mmut.Model_GetNumberOfAllAtoms(self)
    def GetAllAtoms(self): return _mmut.Model_GetAllAtoms(self)
    def GetNumberOfAtoms(self, *args): return _mmut.Model_GetNumberOfAtoms(self, *args)
    def GetAtom(self, *args): return _mmut.Model_GetAtom(self, *args)
    def GetAtomTable(self, *args): return _mmut.Model_GetAtomTable(self, *args)
    def GetAtomTable1(self, *args): return _mmut.Model_GetAtomTable1(self, *args)
    def DeleteAtom(self, *args): return _mmut.Model_DeleteAtom(self, *args)
    def DeleteAllAtoms(self, *args): return _mmut.Model_DeleteAllAtoms(self, *args)
    def DeleteAltLocs(self): return _mmut.Model_DeleteAltLocs(self)
    def AddAtom(self, *args): return _mmut.Model_AddAtom(self, *args)
    def ConvertPDBString(self, *args): return _mmut.Model_ConvertPDBString(self, *args)
    def MakeAtomCIF(self, *args): return _mmut.Model_MakeAtomCIF(self, *args)
    def MakePSCIF(self, *args): return _mmut.Model_MakePSCIF(self, *args)
    def GetCIF(self, *args): return _mmut.Model_GetCIF(self, *args)
    def MoveChain(self, *args): return _mmut.Model_MoveChain(self, *args)
    def GetAIndexRange(self, *args): return _mmut.Model_GetAIndexRange(self, *args)
    def MaskAtoms(self, *args): return _mmut.Model_MaskAtoms(self, *args)
    def MaskResidues(self, *args): return _mmut.Model_MaskResidues(self, *args)
    def MaskChains(self, *args): return _mmut.Model_MaskChains(self, *args)
    def UnmaskAtoms(self, *args): return _mmut.Model_UnmaskAtoms(self, *args)
    def UnmaskResidues(self, *args): return _mmut.Model_UnmaskResidues(self, *args)
    def UnmaskChains(self, *args): return _mmut.Model_UnmaskChains(self, *args)
    def GetNumberOfHelices(self): return _mmut.Model_GetNumberOfHelices(self)
    def GetNumberOfSheets(self): return _mmut.Model_GetNumberOfSheets(self)
    def GetHelix(self, *args): return _mmut.Model_GetHelix(self, *args)
    def GetSheetID(self, *args): return _mmut.Model_GetSheetID(self, *args)
    def GetSheet(self, *args): return _mmut.Model_GetSheet(self, *args)
    def GetNumberOfStrands(self, *args): return _mmut.Model_GetNumberOfStrands(self, *args)
    def GetStrand(self, *args): return _mmut.Model_GetStrand(self, *args)
    def GetHelices(self): return _mmut.Model_GetHelices(self)
    def GetSheets(self): return _mmut.Model_GetSheets(self)
    def RemoveSecStructure(self): return _mmut.Model_RemoveSecStructure(self)
    def CalcSecStructure(self, *args): return _mmut.Model_CalcSecStructure(self, *args)
    def GetHetInfo(self): return _mmut.Model_GetHetInfo(self)
    def RemoveHetInfo(self): return _mmut.Model_RemoveHetInfo(self)
    def GetNumberOfLinks(self): return _mmut.Model_GetNumberOfLinks(self)
    def GetLink(self, *args): return _mmut.Model_GetLink(self, *args)
    def GetLinks(self): return _mmut.Model_GetLinks(self)
    def RemoveLinks(self): return _mmut.Model_RemoveLinks(self)
    def AddLink(self, *args): return _mmut.Model_AddLink(self, *args)
    def GetNumberOfLinkRs(self): return _mmut.Model_GetNumberOfLinkRs(self)
    def GetLinkR(self, *args): return _mmut.Model_GetLinkR(self, *args)
    def GetLinkRs(self): return _mmut.Model_GetLinkRs(self)
    def RemoveLinkRs(self): return _mmut.Model_RemoveLinkRs(self)
    def AddLinkR(self, *args): return _mmut.Model_AddLinkR(self, *args)
    def GetNumberOfCisPeps(self): return _mmut.Model_GetNumberOfCisPeps(self)
    def GetCisPep(self, *args): return _mmut.Model_GetCisPep(self, *args)
    def GetCisPeps(self): return _mmut.Model_GetCisPeps(self)
    def RemoveCisPeps(self): return _mmut.Model_RemoveCisPeps(self)
    def AddCisPep(self, *args): return _mmut.Model_AddCisPep(self, *args)
    def ApplyTransform(self, *args): return _mmut.Model_ApplyTransform(self, *args)
    def isInSelection(self, *args): return _mmut.Model_isInSelection(self, *args)
    def PutUDData(self, *args): return _mmut.Model_PutUDData(self, *args)
    def GetUDData(self, *args): return _mmut.Model_GetUDData(self, *args)
    def Copy(self, *args): return _mmut.Model_Copy(self, *args)
    def CopyHets(self, *args): return _mmut.Model_CopyHets(self, *args)
    def CopySecStructure(self, *args): return _mmut.Model_CopySecStructure(self, *args)
    def CopyLinks(self, *args): return _mmut.Model_CopyLinks(self, *args)
    def CopyLinkRs(self, *args): return _mmut.Model_CopyLinkRs(self, *args)
    def CopyCisPeps(self, *args): return _mmut.Model_CopyCisPeps(self, *args)
Model_swigregister = _mmut.Model_swigregister
Model_swigregister(Model)


def isMetal(*args):
  return _mmut.isMetal(*args)
isMetal = _mmut.isMetal

def getElementNo(*args):
  return _mmut.getElementNo(*args)
getElementNo = _mmut.getElementNo

def getMolecWeight(*args):
  return _mmut.getMolecWeight(*args)
getMolecWeight = _mmut.getMolecWeight

def getCovalentRadius(*args):
  return _mmut.getCovalentRadius(*args)
getCovalentRadius = _mmut.getCovalentRadius

def getVdWaalsRadius(*args):
  return _mmut.getVdWaalsRadius(*args)
getVdWaalsRadius = _mmut.getVdWaalsRadius

def getResidueNo(*args):
  return _mmut.getResidueNo(*args)
getResidueNo = _mmut.getResidueNo
class AAProperty(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AAProperty, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AAProperty, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _mmut.AAProperty_name_set
    __swig_getmethods__["name"] = _mmut.AAProperty_name_get
    if _newclass:name = _swig_property(_mmut.AAProperty_name_get, _mmut.AAProperty_name_set)
    __swig_setmethods__["hydropathy"] = _mmut.AAProperty_hydropathy_set
    __swig_getmethods__["hydropathy"] = _mmut.AAProperty_hydropathy_get
    if _newclass:hydropathy = _swig_property(_mmut.AAProperty_hydropathy_get, _mmut.AAProperty_hydropathy_set)
    __swig_setmethods__["charge"] = _mmut.AAProperty_charge_set
    __swig_getmethods__["charge"] = _mmut.AAProperty_charge_get
    if _newclass:charge = _swig_property(_mmut.AAProperty_charge_get, _mmut.AAProperty_charge_set)
    __swig_setmethods__["relSolvEnergy"] = _mmut.AAProperty_relSolvEnergy_set
    __swig_getmethods__["relSolvEnergy"] = _mmut.AAProperty_relSolvEnergy_get
    if _newclass:relSolvEnergy = _swig_property(_mmut.AAProperty_relSolvEnergy_get, _mmut.AAProperty_relSolvEnergy_set)
    def __init__(self): 
        this = _mmut.new_AAProperty()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_AAProperty
    __del__ = lambda self : None;
AAProperty_swigregister = _mmut.AAProperty_swigregister
AAProperty_swigregister(AAProperty)
nElementNames = cvar.nElementNames
nElementMetals = cvar.nElementMetals
nHydAtomNames = cvar.nHydAtomNames
ELEMENT_UNKNOWN = cvar.ELEMENT_UNKNOWN
nResNames = cvar.nResNames
NAvogadro = cvar.NAvogadro
nSolventNames = cvar.nSolventNames
nAminoacidNames = cvar.nAminoacidNames
nNucleotideNames = cvar.nNucleotideNames


def GetAAPIndex(*args):
  return _mmut.GetAAPIndex(*args)
GetAAPIndex = _mmut.GetAAPIndex

def GetAAHydropathy(*args):
  return _mmut.GetAAHydropathy(*args)
GetAAHydropathy = _mmut.GetAAHydropathy

def GetAACharge(*args):
  return _mmut.GetAACharge(*args)
GetAACharge = _mmut.GetAACharge

def GetAASolvationEnergy(*args):
  return _mmut.GetAASolvationEnergy(*args)
GetAASolvationEnergy = _mmut.GetAASolvationEnergy

def GetAASimilarity(*args):
  return _mmut.GetAASimilarity(*args)
GetAASimilarity = _mmut.GetAASimilarity

def isSolvent(*args):
  return _mmut.isSolvent(*args)
isSolvent = _mmut.isSolvent

def isAminoacid(*args):
  return _mmut.isAminoacid(*args)
isAminoacid = _mmut.isAminoacid

def isNucleotide(*args):
  return _mmut.isNucleotide(*args)
isNucleotide = _mmut.isNucleotide

def isDNARNA(*args):
  return _mmut.isDNARNA(*args)
isDNARNA = _mmut.isDNARNA

def isSugar(*args):
  return _mmut.isSugar(*args)
isSugar = _mmut.isSugar

def Get1LetterCode(*args):
  return _mmut.Get1LetterCode(*args)
Get1LetterCode = _mmut.Get1LetterCode

def Get3LetterCode(*args):
  return _mmut.Get3LetterCode(*args)
Get3LetterCode = _mmut.Get3LetterCode

def GetErrorDescriptionChar(*args):
  return _mmut.GetErrorDescriptionChar(*args)
GetErrorDescriptionChar = _mmut.GetErrorDescriptionChar

def GetAtomTable(*args):
  return _mmut.GetAtomTable(*args)
GetAtomTable = _mmut.GetAtomTable

def GetChainTable(*args):
  return _mmut.GetChainTable(*args)
GetChainTable = _mmut.GetChainTable

def GetResidueTable(*args):
  return _mmut.GetResidueTable(*args)
GetResidueTable = _mmut.GetResidueTable

def GetModelSelIndex(*args):
  return _mmut.GetModelSelIndex(*args)
GetModelSelIndex = _mmut.GetModelSelIndex

def GetChainSelIndex(*args):
  return _mmut.GetChainSelIndex(*args)
GetChainSelIndex = _mmut.GetChainSelIndex

def GetResidueSelIndex(*args):
  return _mmut.GetResidueSelIndex(*args)
GetResidueSelIndex = _mmut.GetResidueSelIndex

def GetAtomSelIndex(*args):
  return _mmut.GetAtomSelIndex(*args)
GetAtomSelIndex = _mmut.GetAtomSelIndex

def getPstr(*args):
  return _mmut.getPstr(*args)
getPstr = _mmut.getPstr

def getAAProperty(*args):
  return _mmut.getAAProperty(*args)
getAAProperty = _mmut.getAAProperty

def getPCChain(*args):
  return _mmut.getPCChain(*args)
getPCChain = _mmut.getPCChain

def getPCResidue(*args):
  return _mmut.getPCResidue(*args)
getPCResidue = _mmut.getPCResidue

def getPPCAtom(*args):
  return _mmut.getPPCAtom(*args)
getPPCAtom = _mmut.getPPCAtom

def getPCAtom(*args):
  return _mmut.getPCAtom(*args)
getPCAtom = _mmut.getPCAtom

def getCAtom(*args):
  return _mmut.getCAtom(*args)
getCAtom = _mmut.getCAtom

def newPPCAtom(*args):
  return _mmut.newPPCAtom(*args)
newPPCAtom = _mmut.newPPCAtom

def delPPCAtom(*args):
  return _mmut.delPPCAtom(*args)
delPPCAtom = _mmut.delPPCAtom

def newPPCResidue(*args):
  return _mmut.newPPCResidue(*args)
newPPCResidue = _mmut.newPPCResidue

def delPPCResidue(*args):
  return _mmut.delPPCResidue(*args)
delPPCResidue = _mmut.delPPCResidue

def newPPCChain(*args):
  return _mmut.newPPCChain(*args)
newPPCChain = _mmut.newPPCChain

def delPPCChain(*args):
  return _mmut.delPPCChain(*args)
delPPCChain = _mmut.delPPCChain

def newpmat44():
  return _mmut.newpmat44()
newpmat44 = _mmut.newpmat44

def delrp(*args):
  return _mmut.delrp(*args)
delrp = _mmut.delrp
class realtypep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, realtypep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, realtypep, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_realtypep()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_realtypep
    __del__ = lambda self : None;
    def assign(self, *args): return _mmut.realtypep_assign(self, *args)
    def value(self): return _mmut.realtypep_value(self)
    def cast(self): return _mmut.realtypep_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.realtypep_frompointer
    if _newclass:frompointer = staticmethod(_mmut.realtypep_frompointer)
realtypep_swigregister = _mmut.realtypep_swigregister
realtypep_swigregister(realtypep)
AAProperties = cvar.AAProperties
AASimilarity = cvar.AASimilarity
NucleotideName = cvar.NucleotideName

def realtypep_frompointer(*args):
  return _mmut.realtypep_frompointer(*args)
realtypep_frompointer = _mmut.realtypep_frompointer

class realtypea(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, realtypea, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, realtypea, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_realtypea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_realtypea
    __del__ = lambda self : None;
    def __getitem__(self, *args): return _mmut.realtypea___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.realtypea___setitem__(self, *args)
    def cast(self): return _mmut.realtypea_cast(self)
    __swig_getmethods__["frompointer"] = lambda x: _mmut.realtypea_frompointer
    if _newclass:frompointer = staticmethod(_mmut.realtypea_frompointer)
realtypea_swigregister = _mmut.realtypea_swigregister
realtypea_swigregister(realtypea)

def realtypea_frompointer(*args):
  return _mmut.realtypea_frompointer(*args)
realtypea_frompointer = _mmut.realtypea_frompointer


def double_to_realtype(*args):
  return _mmut.double_to_realtype(*args)
double_to_realtype = _mmut.double_to_realtype

def realtype_to_double(*args):
  return _mmut.realtype_to_double(*args)
realtype_to_double = _mmut.realtype_to_double
PI = _mmut.PI
class MMUTLipidVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMUTLipidVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMUTLipidVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.MMUTLipidVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.MMUTLipidVector___nonzero__(self)
    def __bool__(self): return _mmut.MMUTLipidVector___bool__(self)
    def __len__(self): return _mmut.MMUTLipidVector___len__(self)
    def pop(self): return _mmut.MMUTLipidVector_pop(self)
    def __getslice__(self, *args): return _mmut.MMUTLipidVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.MMUTLipidVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.MMUTLipidVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.MMUTLipidVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.MMUTLipidVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.MMUTLipidVector___setitem__(self, *args)
    def append(self, *args): return _mmut.MMUTLipidVector_append(self, *args)
    def empty(self): return _mmut.MMUTLipidVector_empty(self)
    def size(self): return _mmut.MMUTLipidVector_size(self)
    def clear(self): return _mmut.MMUTLipidVector_clear(self)
    def swap(self, *args): return _mmut.MMUTLipidVector_swap(self, *args)
    def get_allocator(self): return _mmut.MMUTLipidVector_get_allocator(self)
    def begin(self): return _mmut.MMUTLipidVector_begin(self)
    def end(self): return _mmut.MMUTLipidVector_end(self)
    def rbegin(self): return _mmut.MMUTLipidVector_rbegin(self)
    def rend(self): return _mmut.MMUTLipidVector_rend(self)
    def pop_back(self): return _mmut.MMUTLipidVector_pop_back(self)
    def erase(self, *args): return _mmut.MMUTLipidVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_MMUTLipidVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.MMUTLipidVector_push_back(self, *args)
    def front(self): return _mmut.MMUTLipidVector_front(self)
    def back(self): return _mmut.MMUTLipidVector_back(self)
    def assign(self, *args): return _mmut.MMUTLipidVector_assign(self, *args)
    def resize(self, *args): return _mmut.MMUTLipidVector_resize(self, *args)
    def insert(self, *args): return _mmut.MMUTLipidVector_insert(self, *args)
    def reserve(self, *args): return _mmut.MMUTLipidVector_reserve(self, *args)
    def capacity(self): return _mmut.MMUTLipidVector_capacity(self)
    __swig_destroy__ = _mmut.delete_MMUTLipidVector
    __del__ = lambda self : None;
MMUTLipidVector_swigregister = _mmut.MMUTLipidVector_swigregister
MMUTLipidVector_swigregister(MMUTLipidVector)

class PisaAssemblyTransformationVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PisaAssemblyTransformationVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PisaAssemblyTransformationVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _mmut.PisaAssemblyTransformationVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _mmut.PisaAssemblyTransformationVector___nonzero__(self)
    def __bool__(self): return _mmut.PisaAssemblyTransformationVector___bool__(self)
    def __len__(self): return _mmut.PisaAssemblyTransformationVector___len__(self)
    def pop(self): return _mmut.PisaAssemblyTransformationVector_pop(self)
    def __getslice__(self, *args): return _mmut.PisaAssemblyTransformationVector___getslice__(self, *args)
    def __setslice__(self, *args): return _mmut.PisaAssemblyTransformationVector___setslice__(self, *args)
    def __delslice__(self, *args): return _mmut.PisaAssemblyTransformationVector___delslice__(self, *args)
    def __delitem__(self, *args): return _mmut.PisaAssemblyTransformationVector___delitem__(self, *args)
    def __getitem__(self, *args): return _mmut.PisaAssemblyTransformationVector___getitem__(self, *args)
    def __setitem__(self, *args): return _mmut.PisaAssemblyTransformationVector___setitem__(self, *args)
    def append(self, *args): return _mmut.PisaAssemblyTransformationVector_append(self, *args)
    def empty(self): return _mmut.PisaAssemblyTransformationVector_empty(self)
    def size(self): return _mmut.PisaAssemblyTransformationVector_size(self)
    def clear(self): return _mmut.PisaAssemblyTransformationVector_clear(self)
    def swap(self, *args): return _mmut.PisaAssemblyTransformationVector_swap(self, *args)
    def get_allocator(self): return _mmut.PisaAssemblyTransformationVector_get_allocator(self)
    def begin(self): return _mmut.PisaAssemblyTransformationVector_begin(self)
    def end(self): return _mmut.PisaAssemblyTransformationVector_end(self)
    def rbegin(self): return _mmut.PisaAssemblyTransformationVector_rbegin(self)
    def rend(self): return _mmut.PisaAssemblyTransformationVector_rend(self)
    def pop_back(self): return _mmut.PisaAssemblyTransformationVector_pop_back(self)
    def erase(self, *args): return _mmut.PisaAssemblyTransformationVector_erase(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_PisaAssemblyTransformationVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _mmut.PisaAssemblyTransformationVector_push_back(self, *args)
    def front(self): return _mmut.PisaAssemblyTransformationVector_front(self)
    def back(self): return _mmut.PisaAssemblyTransformationVector_back(self)
    def assign(self, *args): return _mmut.PisaAssemblyTransformationVector_assign(self, *args)
    def resize(self, *args): return _mmut.PisaAssemblyTransformationVector_resize(self, *args)
    def insert(self, *args): return _mmut.PisaAssemblyTransformationVector_insert(self, *args)
    def reserve(self, *args): return _mmut.PisaAssemblyTransformationVector_reserve(self, *args)
    def capacity(self): return _mmut.PisaAssemblyTransformationVector_capacity(self)
    __swig_destroy__ = _mmut.delete_PisaAssemblyTransformationVector
    __del__ = lambda self : None;
PisaAssemblyTransformationVector_swigregister = _mmut.PisaAssemblyTransformationVector_swigregister
PisaAssemblyTransformationVector_swigregister(PisaAssemblyTransformationVector)

class SplineInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SplineInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SplineInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["splines"] = _mmut.SplineInfo_splines_set
    __swig_getmethods__["splines"] = _mmut.SplineInfo_splines_get
    if _newclass:splines = _swig_property(_mmut.SplineInfo_splines_get, _mmut.SplineInfo_splines_set)
    __swig_setmethods__["n1_splines"] = _mmut.SplineInfo_n1_splines_set
    __swig_getmethods__["n1_splines"] = _mmut.SplineInfo_n1_splines_get
    if _newclass:n1_splines = _swig_property(_mmut.SplineInfo_n1_splines_get, _mmut.SplineInfo_n1_splines_set)
    __swig_setmethods__["n2_splines"] = _mmut.SplineInfo_n2_splines_set
    __swig_getmethods__["n2_splines"] = _mmut.SplineInfo_n2_splines_get
    if _newclass:n2_splines = _swig_property(_mmut.SplineInfo_n2_splines_get, _mmut.SplineInfo_n2_splines_set)
    __swig_setmethods__["secstr_indices"] = _mmut.SplineInfo_secstr_indices_set
    __swig_getmethods__["secstr_indices"] = _mmut.SplineInfo_secstr_indices_get
    if _newclass:secstr_indices = _swig_property(_mmut.SplineInfo_secstr_indices_get, _mmut.SplineInfo_secstr_indices_set)
    __swig_setmethods__["colours"] = _mmut.SplineInfo_colours_set
    __swig_getmethods__["colours"] = _mmut.SplineInfo_colours_get
    if _newclass:colours = _swig_property(_mmut.SplineInfo_colours_get, _mmut.SplineInfo_colours_set)
    __swig_setmethods__["nasplines"] = _mmut.SplineInfo_nasplines_set
    __swig_getmethods__["nasplines"] = _mmut.SplineInfo_nasplines_get
    if _newclass:nasplines = _swig_property(_mmut.SplineInfo_nasplines_get, _mmut.SplineInfo_nasplines_set)
    __swig_setmethods__["n1_nasplines"] = _mmut.SplineInfo_n1_nasplines_set
    __swig_getmethods__["n1_nasplines"] = _mmut.SplineInfo_n1_nasplines_get
    if _newclass:n1_nasplines = _swig_property(_mmut.SplineInfo_n1_nasplines_get, _mmut.SplineInfo_n1_nasplines_set)
    __swig_setmethods__["n2_nasplines"] = _mmut.SplineInfo_n2_nasplines_set
    __swig_getmethods__["n2_nasplines"] = _mmut.SplineInfo_n2_nasplines_get
    if _newclass:n2_nasplines = _swig_property(_mmut.SplineInfo_n2_nasplines_get, _mmut.SplineInfo_n2_nasplines_set)
    __swig_setmethods__["nacolours"] = _mmut.SplineInfo_nacolours_set
    __swig_getmethods__["nacolours"] = _mmut.SplineInfo_nacolours_get
    if _newclass:nacolours = _swig_property(_mmut.SplineInfo_nacolours_get, _mmut.SplineInfo_nacolours_set)
    def __init__(self): 
        this = _mmut.new_SplineInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_SplineInfo
    __del__ = lambda self : None;
SplineInfo_swigregister = _mmut.SplineInfo_swigregister
SplineInfo_swigregister(SplineInfo)


def GetSplineInfo(*args):
  return _mmut.GetSplineInfo(*args)
GetSplineInfo = _mmut.GetSplineInfo

def GetCAFromSelection(*args):
  return _mmut.GetCAFromSelection(*args)
GetCAFromSelection = _mmut.GetCAFromSelection

def GetExternalCartesians(*args):
  return _mmut.GetExternalCartesians(*args)
GetExternalCartesians = _mmut.GetExternalCartesians

def GetExternalCartesiansWithSplineInfo(*args):
  return _mmut.GetExternalCartesiansWithSplineInfo(*args)
GetExternalCartesiansWithSplineInfo = _mmut.GetExternalCartesiansWithSplineInfo

def GetRibbonOrWormSplineInfo(*args):
  return _mmut.GetRibbonOrWormSplineInfo(*args)
GetRibbonOrWormSplineInfo = _mmut.GetRibbonOrWormSplineInfo
class CMMUTManager(Manager):
    __swig_setmethods__ = {}
    for _s in [Manager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMUTManager, name, value)
    __swig_getmethods__ = {}
    for _s in [Manager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CMMUTManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_CMMUTManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMMUTManager
    __del__ = lambda self : None;
    def get_cell(self): return _mmut.CMMUTManager_get_cell(self)
    def get_cell_p(self): return _mmut.CMMUTManager_get_cell_p(self)
    def ListAtomInfo(self, *args): return _mmut.CMMUTManager_ListAtomInfo(self, *args)
    def PrintAtomicComposition(self, *args): return _mmut.CMMUTManager_PrintAtomicComposition(self, *args)
    def PrintResidueComposition(self, *args): return _mmut.CMMUTManager_PrintResidueComposition(self, *args)
    def PrintSequence(self, *args): return _mmut.CMMUTManager_PrintSequence(self, *args)
    def PrintBValues(self, *args): return _mmut.CMMUTManager_PrintBValues(self, *args)
    def NumberOfHydrogens(self, *args): return _mmut.CMMUTManager_NumberOfHydrogens(self, *args)
    def ResNoLookup(self, *args): return _mmut.CMMUTManager_ResNoLookup(self, *args)
    def TotalNumRes(self, *args): return _mmut.CMMUTManager_TotalNumRes(self, *args)
    def GetSequence(self, *args): return _mmut.CMMUTManager_GetSequence(self, *args)
    def GetSequenceFromResidues(self, *args): return _mmut.CMMUTManager_GetSequenceFromResidues(self, *args)
    def SelectOneAtomForNonAminoNucleotide(self, *args): return _mmut.CMMUTManager_SelectOneAtomForNonAminoNucleotide(self, *args)
    def AtomicComposition(self, *args): return _mmut.CMMUTManager_AtomicComposition(self, *args)
    def ResidueComposition(self, *args): return _mmut.CMMUTManager_ResidueComposition(self, *args)
    def NextResidue(self, *args): return _mmut.CMMUTManager_NextResidue(self, *args)
    def BondLength(self, *args): return _mmut.CMMUTManager_BondLength(self, *args)
    def TorsionAngle(self, *args): return _mmut.CMMUTManager_TorsionAngle(self, *args)
    def MolWeight(self, *args): return _mmut.CMMUTManager_MolWeight(self, *args)
    def MolWeightWithH(self, *args): return _mmut.CMMUTManager_MolWeightWithH(self, *args)
    def GetBValues(self, *args): return _mmut.CMMUTManager_GetBValues(self, *args)
    def GetBValuesDoubleVector(self, *args): return _mmut.CMMUTManager_GetBValuesDoubleVector(self, *args)
    def CentreOfMass(self, *args): return _mmut.CMMUTManager_CentreOfMass(self, *args)
    def CentreOfMassAsCartesian(self, *args): return _mmut.CMMUTManager_CentreOfMassAsCartesian(self, *args)
    def Mass(self, *args): return _mmut.CMMUTManager_Mass(self, *args)
    def CentreOfCoordinates(self, *args): return _mmut.CMMUTManager_CentreOfCoordinates(self, *args)
    def CentreOfCoordinatesAsCartesian(self, *args): return _mmut.CMMUTManager_CentreOfCoordinatesAsCartesian(self, *args)
    def NumberOfAtoms(self, *args): return _mmut.CMMUTManager_NumberOfAtoms(self, *args)
    def Extent(self, *args): return _mmut.CMMUTManager_Extent(self, *args)
    def ExtentSize(self, *args): return _mmut.CMMUTManager_ExtentSize(self, *args)
    def GetPrincipalComponents(self, *args): return _mmut.CMMUTManager_GetPrincipalComponents(self, *args)
    def isMainChain(self, *args): return _mmut.CMMUTManager_isMainChain(self, *args)
    def doAltLocMatch(self, *args): return _mmut.CMMUTManager_doAltLocMatch(self, *args)
    def NameComparison(self, *args): return _mmut.CMMUTManager_NameComparison(self, *args)
    def TrimString(self, *args): return _mmut.CMMUTManager_TrimString(self, *args)
    def AtomLabel(self, *args): return _mmut.CMMUTManager_AtomLabel(self, *args)
    def ChainIDisDigit(self, *args): return _mmut.CMMUTManager_ChainIDisDigit(self, *args)
    def AtomLabel_atom1(self, *args): return _mmut.CMMUTManager_AtomLabel_atom1(self, *args)
    def AtomLabel_atom(self, *args): return _mmut.CMMUTManager_AtomLabel_atom(self, *args)
    def AtomLabel_residue(self, *args): return _mmut.CMMUTManager_AtomLabel_residue(self, *args)
    def AtomLabel_chain(self, *args): return _mmut.CMMUTManager_AtomLabel_chain(self, *args)
    def AtomLabel_residue1(self, *args): return _mmut.CMMUTManager_AtomLabel_residue1(self, *args)
    def AtomLabel_mask(self, *args): return _mmut.CMMUTManager_AtomLabel_mask(self, *args)
    def WriteSelection(self, *args): return _mmut.CMMUTManager_WriteSelection(self, *args)
    def PutSelectedAtoms(self, *args): return _mmut.CMMUTManager_PutSelectedAtoms(self, *args)
    def CopySelection(self, *args): return _mmut.CMMUTManager_CopySelection(self, *args)
    def FindCloseAtomPairs(self, *args): return _mmut.CMMUTManager_FindCloseAtomPairs(self, *args)
    def FixElementNames(self): return _mmut.CMMUTManager_FixElementNames(self)
    def Source(self): return _mmut.CMMUTManager_Source(self)
    def Unknowns(self): return _mmut.CMMUTManager_Unknowns(self)
    def GetRemarksString(self): return _mmut.CMMUTManager_GetRemarksString(self)
    def SiteInfo(self): return _mmut.CMMUTManager_SiteInfo(self)
    def Resolution(self): return _mmut.CMMUTManager_Resolution(self)
    def StructureTitle(self): return _mmut.CMMUTManager_StructureTitle(self)
    def ApplyPDBSecStructure(self, *args): return _mmut.CMMUTManager_ApplyPDBSecStructure(self, *args)
    def GetCellInfo(self): return _mmut.CMMUTManager_GetCellInfo(self)
    def MMUTGetSpaceGroup(self): return _mmut.CMMUTManager_MMUTGetSpaceGroup(self)
    def SelectionToSCOP(self, *args): return _mmut.CMMUTManager_SelectionToSCOP(self, *args)
    def GetBiomoleculeAsMatrices(self, *args): return _mmut.CMMUTManager_GetBiomoleculeAsMatrices(self, *args)
    __swig_getmethods__["GetCAModel"] = lambda x: _mmut.CMMUTManager_GetCAModel
    if _newclass:GetCAModel = staticmethod(_mmut.CMMUTManager_GetCAModel)
    def GenerateTransformedChain(self, *args): return _mmut.CMMUTManager_GenerateTransformedChain(self, *args)
    def RemoveSmallHelices(self, *args): return _mmut.CMMUTManager_RemoveSmallHelices(self, *args)
    def SelectAminoNotHet(self, *args): return _mmut.CMMUTManager_SelectAminoNotHet(self, *args)
    def isNTerminusBound(self, *args): return _mmut.CMMUTManager_isNTerminusBound(self, *args)
    def isPeptideBound(self, *args): return _mmut.CMMUTManager_isPeptideBound(self, *args)
    def GetNonTerAllSelHnd(self): return _mmut.CMMUTManager_GetNonTerAllSelHnd(self)
    def GetTMatrix(self, *args): return _mmut.CMMUTManager_GetTMatrix(self, *args)
CMMUTManager_swigregister = _mmut.CMMUTManager_swigregister
CMMUTManager_swigregister(CMMUTManager)

def CMMUTManager_GetCAModel(*args):
  return _mmut.CMMUTManager_GetCAModel(*args)
CMMUTManager_GetCAModel = _mmut.CMMUTManager_GetCAModel

class PisaAssemblyTransformation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PisaAssemblyTransformation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PisaAssemblyTransformation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_PisaAssemblyTransformation(*args)
        try: self.this.append(this)
        except: self.this = this
    def Selection(self): return _mmut.PisaAssemblyTransformation_Selection(self)
    def VisualID(self): return _mmut.PisaAssemblyTransformation_VisualID(self)
    def Transformation(self): return _mmut.PisaAssemblyTransformation_Transformation(self)
    __swig_destroy__ = _mmut.delete_PisaAssemblyTransformation
    __del__ = lambda self : None;
PisaAssemblyTransformation_swigregister = _mmut.PisaAssemblyTransformation_swigregister
PisaAssemblyTransformation_swigregister(PisaAssemblyTransformation)

MAXSETS = _mmut.MAXSETS
SELECT_ALL = _mmut.SELECT_ALL
SELECT_SAME = _mmut.SELECT_SAME
SELECT_NOT = _mmut.SELECT_NOT
class CMMANBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMANBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMMANBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CMMANBase(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMMANBase
    __del__ = lambda self : None;
    def SetSelHandle(self, *args): return _mmut.CMMANBase_SetSelHandle(self, *args)
    def GetSelection(self, *args): return _mmut.CMMANBase_GetSelection(self, *args)
    def ClearSelection(self, *args): return _mmut.CMMANBase_ClearSelection(self, *args)
    def GetOneModel(self, *args): return _mmut.CMMANBase_GetOneModel(self, *args)
    def SetExclusions(self, *args): return _mmut.CMMANBase_SetExclusions(self, *args)
    def GetMolHnd(self, iset=0): return _mmut.CMMANBase_GetMolHnd(self, iset)
    def SetMolHnd(self, *args): return _mmut.CMMANBase_SetMolHnd(self, *args)
CMMANBase_swigregister = _mmut.CMMANBase_swigregister
CMMANBase_swigregister(CMMANBase)

HBTYPE = _mmut.HBTYPE
VDWRADIUS = _mmut.VDWRADIUS
VDWHRADIUS = _mmut.VDWHRADIUS
IONRADIUS = _mmut.IONRADIUS
PROPERTY_B = _mmut.PROPERTY_B
PROPERTY_OCC = _mmut.PROPERTY_OCC
PROPERTY_CHARGE = _mmut.PROPERTY_CHARGE
PROPERTY_X = _mmut.PROPERTY_X
PROPERTY_Y = _mmut.PROPERTY_Y
PROPERTY_Z = _mmut.PROPERTY_Z
PROPERTY_SEC = _mmut.PROPERTY_SEC
PROPERTY_ATOM_SAS = _mmut.PROPERTY_ATOM_SAS
PROPERTY_RES_SAS = _mmut.PROPERTY_RES_SAS
PROPERTY_ATOM_CONTACT = _mmut.PROPERTY_ATOM_CONTACT
PROPERTY_RES_CONTACT = _mmut.PROPERTY_RES_CONTACT
PROPERTY_SERIAL = _mmut.PROPERTY_SERIAL
MMAN_COORDINATES = _mmut.MMAN_COORDINATES
MMAN_XTLDATA = _mmut.MMAN_XTLDATA

def GetMMANManager(*args):
  return _mmut.GetMMANManager(*args)
GetMMANManager = _mmut.GetMMANManager

def GetMMANManagerAddress(*args):
  return _mmut.GetMMANManagerAddress(*args)
GetMMANManagerAddress = _mmut.GetMMANManagerAddress

def GetPDBFromSRSEntryName(*args):
  return _mmut.GetPDBFromSRSEntryName(*args)
GetPDBFromSRSEntryName = _mmut.GetPDBFromSRSEntryName
class CMMANManager(CMMUTManager):
    __swig_setmethods__ = {}
    for _s in [CMMUTManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMANManager, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMUTManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CMMANManager, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CMMANManager(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMMANManager
    __del__ = lambda self : None;
    def GetMonomerSVG(self, *args): return _mmut.CMMANManager_GetMonomerSVG(self, *args)
    def GetMonomerSVGs(self): return _mmut.CMMANManager_GetMonomerSVGs(self)
    def setCustomResCIFFiles(self, *args): return _mmut.CMMANManager_setCustomResCIFFiles(self, *args)
    def GetSRS(self): return _mmut.CMMANManager_GetSRS(self)
    def GetSrsAtoms(self): return _mmut.CMMANManager_GetSrsAtoms(self)
    def GetSASArea(self, *args): return _mmut.CMMANManager_GetSASArea(self, *args)
    def GetMolBonds(self, aromaticize=True): return _mmut.CMMANManager_GetMolBonds(self, aromaticize)
    def EditBonds(self, *args): return _mmut.CMMANManager_EditBonds(self, *args)
    def GetAtomRadii(self, *args): return _mmut.CMMANManager_GetAtomRadii(self, *args)
    def GetAtomEnergyType(self, *args): return _mmut.CMMANManager_GetAtomEnergyType(self, *args)
    def GetMetalCoordinationDistance(self, *args): return _mmut.CMMANManager_GetMetalCoordinationDistance(self, *args)
    def GetAtomVDWRadius(self, *args): return _mmut.CMMANManager_GetAtomVDWRadius(self, *args)
    def GetAtomIonRadius(self, *args): return _mmut.CMMANManager_GetAtomIonRadius(self, *args)
    def GetAtomHBondType1(self, *args): return _mmut.CMMANManager_GetAtomHBondType1(self, *args)
    def LoadCharge(self, *args): return _mmut.CMMANManager_LoadCharge(self, *args)
    def PrintCharges(self): return _mmut.CMMANManager_PrintCharges(self)
    def SetLabelMask(self, *args): return _mmut.CMMANManager_SetLabelMask(self, *args)
    def AtomLabel(self, *args): return _mmut.CMMANManager_AtomLabel(self, *args)
    def ListBonds(self, *args): return _mmut.CMMANManager_ListBonds(self, *args)
    def ListSecStructure(self, *args): return _mmut.CMMANManager_ListSecStructure(self, *args)
    def TestBonding(self, *args): return _mmut.CMMANManager_TestBonding(self, *args)
    def RestoreData(self, *args): return _mmut.CMMANManager_RestoreData(self, *args)
    def LoadUDDData(self, *args): return _mmut.CMMANManager_LoadUDDData(self, *args)
    def CopyModel(self, *args): return _mmut.CMMANManager_CopyModel(self, *args)
    def GenerateSymmetryModel(self, *args): return _mmut.CMMANManager_GenerateSymmetryModel(self, *args)
    def GenerateTransformedModel(self, *args): return _mmut.CMMANManager_GenerateTransformedModel(self, *args)
    def ApplyTransformtoModel(self, *args): return _mmut.CMMANManager_ApplyTransformtoModel(self, *args)
    def GetSymOpTitle(self, *args): return _mmut.CMMANManager_GetSymOpTitle(self, *args)
    def ApplySymmetrytoModel(self, *args): return _mmut.CMMANManager_ApplySymmetrytoModel(self, *args)
    def IfSymmetryNeighbours(self, *args): return _mmut.CMMANManager_IfSymmetryNeighbours(self, *args)
    def MoveFragment(self, *args): return _mmut.CMMANManager_MoveFragment(self, *args)
    def SelectChainTermini(self): return _mmut.CMMANManager_SelectChainTermini(self)
    def SelectSSETermini(self, *args): return _mmut.CMMANManager_SelectSSETermini(self, *args)
    def isAminoacid(self, *args): return _mmut.CMMANManager_isAminoacid(self, *args)
    def isDNARNA(self, *args): return _mmut.CMMANManager_isDNARNA(self, *args)
    def GetRestypeCode(self, *args): return _mmut.CMMANManager_GetRestypeCode(self, *args)
    def SetCustomRestype(self, *args): return _mmut.CMMANManager_SetCustomRestype(self, *args)
    def SetCustomResSynonym(self, *args): return _mmut.CMMANManager_SetCustomResSynonym(self, *args)
    def ExcludeOverlappedAtoms(self, *args): return _mmut.CMMANManager_ExcludeOverlappedAtoms(self, *args)
    def SetTransform(self, *args): return _mmut.CMMANManager_SetTransform(self, *args)
    def ReApplyTransform(self, reset=0): return _mmut.CMMANManager_ReApplyTransform(self, reset)
    def UnSetTransform(self, apply_inverse=1): return _mmut.CMMANManager_UnSetTransform(self, apply_inverse)
    def GetTransform(self): return _mmut.CMMANManager_GetTransform(self)
    def GetTransformString(self): return _mmut.CMMANManager_GetTransformString(self)
    def GetIsTransformed(self): return _mmut.CMMANManager_GetIsTransformed(self)
    def AtomicRMSDistance(self, *args): return _mmut.CMMANManager_AtomicRMSDistance(self, *args)
    def TransformToSuperposeAtoms(self, *args): return _mmut.CMMANManager_TransformToSuperposeAtoms(self, *args)
    def TransformToSuperposeCloseAtoms(self, *args): return _mmut.CMMANManager_TransformToSuperposeCloseAtoms(self, *args)
    def DeltaResidueOrientation(self, *args): return _mmut.CMMANManager_DeltaResidueOrientation(self, *args)
    def CopyCoordinates(self, *args): return _mmut.CMMANManager_CopyCoordinates(self, *args)
    def LoadSerial(self, *args): return _mmut.CMMANManager_LoadSerial(self, *args)
    def LoadSerialFromDifferentModel(self, *args): return _mmut.CMMANManager_LoadSerialFromDifferentModel(self, *args)
    def GetUnremediated(self): return _mmut.CMMANManager_GetUnremediated(self)
    def GetNumberOfSecStructure(self, *args): return _mmut.CMMANManager_GetNumberOfSecStructure(self, *args)
    def PrintSecStructure(self): return _mmut.CMMANManager_PrintSecStructure(self)
    def GetLibTMatrix(self, *args): return _mmut.CMMANManager_GetLibTMatrix(self, *args)
    def ApplyCartesiansDeltas(self, *args): return _mmut.CMMANManager_ApplyCartesiansDeltas(self, *args)
    def GetAddress(self): return _mmut.CMMANManager_GetAddress(self)
    def GeneratePISAAssembly(self, *args): return _mmut.CMMANManager_GeneratePISAAssembly(self, *args)
CMMANManager_swigregister = _mmut.CMMANManager_swigregister
CMMANManager_swigregister(CMMANManager)


def setrealp(*args):
  return _mmut.setrealp(*args)
setrealp = _mmut.setrealp

def setrealpp(*args):
  return _mmut.setrealpp(*args)
setrealpp = _mmut.setrealpp

def setintp(*args):
  return _mmut.setintp(*args)
setintp = _mmut.setintp

def setintpp(*args):
  return _mmut.setintpp(*args)
setintpp = _mmut.setintpp

def getrealp(*args):
  return _mmut.getrealp(*args)
getrealp = _mmut.getrealp

def getrealpp(*args):
  return _mmut.getrealpp(*args)
getrealpp = _mmut.getrealpp

def getintp(*args):
  return _mmut.getintp(*args)
getintp = _mmut.getintp

def getintpp(*args):
  return _mmut.getintpp(*args)
getintpp = _mmut.getintpp

def printrealp(*args):
  return _mmut.printrealp(*args)
printrealp = _mmut.printrealp

def printrealpp(*args):
  return _mmut.printrealpp(*args)
printrealpp = _mmut.printrealpp

def printintp(*args):
  return _mmut.printintp(*args)
printintp = _mmut.printintp

def printintpp(*args):
  return _mmut.printintpp(*args)
printintpp = _mmut.printintpp

def PPCAtomsToCartesians(*args):
  return _mmut.PPCAtomsToCartesians(*args)
PPCAtomsToCartesians = _mmut.PPCAtomsToCartesians
class CMolBondParams(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMolBondParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMolBondParams, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_CMolBondParams()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMolBondParams
    __del__ = lambda self : None;
CMolBondParams_swigregister = _mmut.CMolBondParams_swigregister
CMolBondParams_swigregister(CMolBondParams)

class CMolBonds(CMMANBase):
    __swig_setmethods__ = {}
    for _s in [CMMANBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMolBonds, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMANBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CMolBonds, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CMolBonds(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMolBonds
    __del__ = lambda self : None;
    def FindBonds(self, *args): return _mmut.CMolBonds_FindBonds(self, *args)
    def GetMonomerSVG(self, *args): return _mmut.CMolBonds_GetMonomerSVG(self, *args)
    def GetMonomerSVGs(self): return _mmut.CMolBonds_GetMonomerSVGs(self)
    def AddConnection(self, *args): return _mmut.CMolBonds_AddConnection(self, *args)
    def DeleteConnection(self, *args): return _mmut.CMolBonds_DeleteConnection(self, *args)
    def isInterResBond(self, *args): return _mmut.CMolBonds_isInterResBond(self, *args)
    def IntraResContacts(self, *args): return _mmut.CMolBonds_IntraResContacts(self, *args)
    def ltBondDistance(self, *args): return _mmut.CMolBonds_ltBondDistance(self, *args)
CMolBonds_swigregister = _mmut.CMolBonds_swigregister
CMolBonds_swigregister(CMolBonds)

NOSECSTR = _mmut.NOSECSTR
BETA = _mmut.BETA
BULGE = _mmut.BULGE
TURN3 = _mmut.TURN3
TURN4 = _mmut.TURN4
TURN5 = _mmut.TURN5
ALPHA = _mmut.ALPHA
class CSecStructure(CMMANBase):
    __swig_setmethods__ = {}
    for _s in [CMMANBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSecStructure, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMANBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSecStructure, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CSecStructure(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CSecStructure
    __del__ = lambda self : None;
    def GetSecondaryStructure(self, *args): return _mmut.CSecStructure_GetSecondaryStructure(self, *args)
    def SetParams(self, *args): return _mmut.CSecStructure_SetParams(self, *args)
    def GetHBonds(self, imodel=0): return _mmut.CSecStructure_GetHBonds(self, imodel)
    def GetSecStr(self, imodel=0): return _mmut.CSecStructure_GetSecStr(self, imodel)
    def SetFlagBulge(self, *args): return _mmut.CSecStructure_SetFlagBulge(self, *args)
    def Print(self, imodel=0): return _mmut.CSecStructure_Print(self, imodel)
    def ClearMemory(self): return _mmut.CSecStructure_ClearMemory(self)
    def GetHBondAtoms(self, imodel=0): return _mmut.CSecStructure_GetHBondAtoms(self, imodel)
CSecStructure_swigregister = _mmut.CSecStructure_swigregister
CSecStructure_swigregister(CSecStructure)

SURFACEPOINTS = _mmut.SURFACEPOINTS
WODAKJANIN = _mmut.WODAKJANIN
LEERICHARDS = _mmut.LEERICHARDS
class CSASArea(CMMANBase):
    __swig_setmethods__ = {}
    for _s in [CMMANBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CSASArea, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMANBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CSASArea, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CSASArea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CSASArea
    __del__ = lambda self : None;
    def InitParams(self): return _mmut.CSASArea_InitParams(self)
    def SetParams(self, *args): return _mmut.CSASArea_SetParams(self, *args)
    def SetMethod(self, *args): return _mmut.CSASArea_SetMethod(self, *args)
    def Calculate_Contact(self): return _mmut.CSASArea_Calculate_Contact(self)
    def Calculate(self, imodel=0, separate_models=0): return _mmut.CSASArea_Calculate(self, imodel, separate_models)
    def Calculate0(self, *args): return _mmut.CSASArea_Calculate0(self, *args)
    def SetUDD(self, *args): return _mmut.CSASArea_SetUDD(self, *args)
    def Print(self, *args): return _mmut.CSASArea_Print(self, *args)
CSASArea_swigregister = _mmut.CSASArea_swigregister
CSASArea_swigregister(CSASArea)

MIN_D_A = _mmut.MIN_D_A
MAX_D_A = _mmut.MAX_D_A
MAX_H_A = _mmut.MAX_H_A
MIN_DD_D_A = _mmut.MIN_DD_D_A
MIN_D_A_AA = _mmut.MIN_D_A_AA
MIN_H_A_AA = _mmut.MIN_H_A_AA
MIN_D_H_A = _mmut.MIN_D_H_A
class CHBond(CMMANBase):
    __swig_setmethods__ = {}
    for _s in [CMMANBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CHBond, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMANBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CHBond, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CHBond(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CHBond
    __del__ = lambda self : None;
    def InitParams(self): return _mmut.CHBond_InitParams(self)
    def SetParams(self, *args): return _mmut.CHBond_SetParams(self, *args)
    def Calculate(self, separate_models=0): return _mmut.CHBond_Calculate(self, separate_models)
    def Calculate0(self, model=0): return _mmut.CHBond_Calculate0(self, model)
    def LoadUDDHBType(self, *args): return _mmut.CHBond_LoadUDDHBType(self, *args)
    def Print(self, geometry=1): return _mmut.CHBond_Print(self, geometry)
    __swig_setmethods__["hbonds"] = _mmut.CHBond_hbonds_set
    __swig_getmethods__["hbonds"] = _mmut.CHBond_hbonds_get
    if _newclass:hbonds = _swig_property(_mmut.CHBond_hbonds_get, _mmut.CHBond_hbonds_set)
CHBond_swigregister = _mmut.CHBond_swigregister
CHBond_swigregister(CHBond)

class CContact(CMMANBase):
    __swig_setmethods__ = {}
    for _s in [CMMANBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CContact, name, value)
    __swig_getmethods__ = {}
    for _s in [CMMANBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CContact, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CContact(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CContact
    __del__ = lambda self : None;
    def InitParams(self): return _mmut.CContact_InitParams(self)
    def SetParams(self, *args): return _mmut.CContact_SetParams(self, *args)
    def Calculate(self, separate_models=1): return _mmut.CContact_Calculate(self, separate_models)
    def Calculate0(self, model=0): return _mmut.CContact_Calculate0(self, model)
    def Print(self, geometry=1): return _mmut.CContact_Print(self, geometry)
    __swig_setmethods__["close_contacts"] = _mmut.CContact_close_contacts_set
    __swig_getmethods__["close_contacts"] = _mmut.CContact_close_contacts_get
    if _newclass:close_contacts = _swig_property(_mmut.CContact_close_contacts_get, _mmut.CContact_close_contacts_set)
CContact_swigregister = _mmut.CContact_swigregister
CContact_swigregister(CContact)

CONN_POINT_POINT = _mmut.CONN_POINT_POINT
CONN_ATOM_POINT = _mmut.CONN_ATOM_POINT
CONN_POINT_ATOM = _mmut.CONN_POINT_ATOM
CONN_ATOM_ATOM = _mmut.CONN_ATOM_ATOM
CONN_ATOM_DISP = _mmut.CONN_ATOM_DISP
CONN_POINT_DISP = _mmut.CONN_POINT_DISP
class Connection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Connection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Connection, name)
    __repr__ = _swig_repr
    __swig_setmethods__["isInTotalSelection"] = _mmut.Connection_isInTotalSelection_set
    __swig_getmethods__["isInTotalSelection"] = _mmut.Connection_isInTotalSelection_get
    if _newclass:isInTotalSelection = _swig_property(_mmut.Connection_isInTotalSelection_get, _mmut.Connection_isInTotalSelection_set)
    __swig_setmethods__["external_connected_atoms"] = _mmut.Connection_external_connected_atoms_set
    __swig_getmethods__["external_connected_atoms"] = _mmut.Connection_external_connected_atoms_get
    if _newclass:external_connected_atoms = _swig_property(_mmut.Connection_external_connected_atoms_get, _mmut.Connection_external_connected_atoms_set)
    __swig_setmethods__["external_connected_spline_atoms"] = _mmut.Connection_external_connected_spline_atoms_set
    __swig_getmethods__["external_connected_spline_atoms"] = _mmut.Connection_external_connected_spline_atoms_get
    if _newclass:external_connected_spline_atoms = _swig_property(_mmut.Connection_external_connected_spline_atoms_get, _mmut.Connection_external_connected_spline_atoms_set)
    __swig_setmethods__["connected_atoms"] = _mmut.Connection_connected_atoms_set
    __swig_getmethods__["connected_atoms"] = _mmut.Connection_connected_atoms_get
    if _newclass:connected_atoms = _swig_property(_mmut.Connection_connected_atoms_get, _mmut.Connection_connected_atoms_set)
    __swig_setmethods__["orders"] = _mmut.Connection_orders_set
    __swig_getmethods__["orders"] = _mmut.Connection_orders_get
    if _newclass:orders = _swig_property(_mmut.Connection_orders_get, _mmut.Connection_orders_set)
    __swig_setmethods__["external_orders"] = _mmut.Connection_external_orders_set
    __swig_getmethods__["external_orders"] = _mmut.Connection_external_orders_get
    if _newclass:external_orders = _swig_property(_mmut.Connection_external_orders_get, _mmut.Connection_external_orders_set)
    def __init__(self): 
        this = _mmut.new_Connection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Connection
    __del__ = lambda self : None;
    def AddConnection(self, *args): return _mmut.Connection_AddConnection(self, *args)
    def AddExternalConnection(self, *args): return _mmut.Connection_AddExternalConnection(self, *args)
    def AddExternalSplineConnection(self, *args): return _mmut.Connection_AddExternalSplineConnection(self, *args)
Connection_swigregister = _mmut.Connection_swigregister
Connection_swigregister(Connection)

class Connectivity(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Connectivity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Connectivity, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_Connectivity()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Connectivity
    __del__ = lambda self : None;
    def AddBonds(self, *args): return _mmut.Connectivity_AddBonds(self, *args)
    def AddContacts(self, *args): return _mmut.Connectivity_AddContacts(self, *args)
    def AddTrace(self, *args): return _mmut.Connectivity_AddTrace(self, *args)
    def AddTraceByChain(self, *args): return _mmut.Connectivity_AddTraceByChain(self, *args)
    def GetConnectivityLists(self): return _mmut.Connectivity_GetConnectivityLists(self)
    def GetExternalConnectivityLists(self): return _mmut.Connectivity_GetExternalConnectivityLists(self)
    def GetExternalSplineConnectivityLists(self): return _mmut.Connectivity_GetExternalSplineConnectivityLists(self)
    def GetNumberOfAtoms(self): return _mmut.Connectivity_GetNumberOfAtoms(self)
    def GetNumberOfExternalBonds(self): return _mmut.Connectivity_GetNumberOfExternalBonds(self)
    def GetAtoms(self): return _mmut.Connectivity_GetAtoms(self)
    def GetCAtomIndex(self): return _mmut.Connectivity_GetCAtomIndex(self)
    def Clear(self): return _mmut.Connectivity_Clear(self)
Connectivity_swigregister = _mmut.Connectivity_swigregister
Connectivity_swigregister(Connectivity)

class Connectivity2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Connectivity2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Connectivity2, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pAtom1"] = _mmut.Connectivity2_pAtom1_set
    __swig_getmethods__["pAtom1"] = _mmut.Connectivity2_pAtom1_get
    if _newclass:pAtom1 = _swig_property(_mmut.Connectivity2_pAtom1_get, _mmut.Connectivity2_pAtom1_set)
    __swig_setmethods__["pAtom2"] = _mmut.Connectivity2_pAtom2_set
    __swig_getmethods__["pAtom2"] = _mmut.Connectivity2_pAtom2_get
    if _newclass:pAtom2 = _swig_property(_mmut.Connectivity2_pAtom2_get, _mmut.Connectivity2_pAtom2_set)
    __swig_setmethods__["XYZ1"] = _mmut.Connectivity2_XYZ1_set
    __swig_getmethods__["XYZ1"] = _mmut.Connectivity2_XYZ1_get
    if _newclass:XYZ1 = _swig_property(_mmut.Connectivity2_XYZ1_get, _mmut.Connectivity2_XYZ1_set)
    __swig_setmethods__["connected"] = _mmut.Connectivity2_connected_set
    __swig_getmethods__["connected"] = _mmut.Connectivity2_connected_get
    if _newclass:connected = _swig_property(_mmut.Connectivity2_connected_get, _mmut.Connectivity2_connected_set)
    __swig_setmethods__["tags"] = _mmut.Connectivity2_tags_set
    __swig_getmethods__["tags"] = _mmut.Connectivity2_tags_get
    if _newclass:tags = _swig_property(_mmut.Connectivity2_tags_get, _mmut.Connectivity2_tags_set)
    __swig_setmethods__["selected"] = _mmut.Connectivity2_selected_set
    __swig_getmethods__["selected"] = _mmut.Connectivity2_selected_get
    if _newclass:selected = _swig_property(_mmut.Connectivity2_selected_get, _mmut.Connectivity2_selected_set)
    def __init__(self, *args): 
        this = _mmut.new_Connectivity2(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_Connectivity2
    __del__ = lambda self : None;
    def AddConnectionsFromMatches(self, *args): return _mmut.Connectivity2_AddConnectionsFromMatches(self, *args)
    def AddConnection(self, *args): return _mmut.Connectivity2_AddConnection(self, *args)
    def InsertConnection(self, *args): return _mmut.Connectivity2_InsertConnection(self, *args)
    def AddUniqueConnection(self, *args): return _mmut.Connectivity2_AddUniqueConnection(self, *args)
    def UpdateCoordinates(self, label_dist=False): return _mmut.Connectivity2_UpdateCoordinates(self, label_dist)
    def RemoveConnection(self, *args): return _mmut.Connectivity2_RemoveConnection(self, *args)
    def DeleteConnection(self, *args): return _mmut.Connectivity2_DeleteConnection(self, *args)
    def DeleteConnections(self, *args): return _mmut.Connectivity2_DeleteConnections(self, *args)
    def DeleteTaggedConnections(self, *args): return _mmut.Connectivity2_DeleteTaggedConnections(self, *args)
    def GetNofConnections(self): return _mmut.Connectivity2_GetNofConnections(self)
    def FindConnections(self, *args): return _mmut.Connectivity2_FindConnections(self, *args)
    def FindNofConnections(self, *args): return _mmut.Connectivity2_FindNofConnections(self, *args)
    def Clear(self): return _mmut.Connectivity2_Clear(self)
    def SelectVectors(self, *args): return _mmut.Connectivity2_SelectVectors(self, *args)
    def Extent(self): return _mmut.Connectivity2_Extent(self)
    def Print(self, tag1="", tag2=""): return _mmut.Connectivity2_Print(self, tag1, tag2)
    def DataMode(self): return _mmut.Connectivity2_DataMode(self)
    def GetLabel(self, *args): return _mmut.Connectivity2_GetLabel(self, *args)
    def GetCoordinate(self, *args): return _mmut.Connectivity2_GetCoordinate(self, *args)
    def GetAtom(self, *args): return _mmut.Connectivity2_GetAtom(self, *args)
    def GetAtomID(self, *args): return _mmut.Connectivity2_GetAtomID(self, *args)
    def GetTag(self, *args): return _mmut.Connectivity2_GetTag(self, *args)
    def SetTag(self, *args): return _mmut.Connectivity2_SetTag(self, *args)
    def GetRMSD(self): return _mmut.Connectivity2_GetRMSD(self)
    def AddContactFromSelHandle(self, *args): return _mmut.Connectivity2_AddContactFromSelHandle(self, *args)
    def AddContacts(self, *args): return _mmut.Connectivity2_AddContacts(self, *args)
    def AddRangeConnections(self, *args): return _mmut.Connectivity2_AddRangeConnections(self, *args)
    def AddCloseRangeConnections(self, *args): return _mmut.Connectivity2_AddCloseRangeConnections(self, *args)
    def AddRangeWithSameIdConnections(self, *args): return _mmut.Connectivity2_AddRangeWithSameIdConnections(self, *args)
    def AddCloseAtoms(self, *args): return _mmut.Connectivity2_AddCloseAtoms(self, *args)
    def GetSelection(self, mode=1): return _mmut.Connectivity2_GetSelection(self, mode)
    def Superpose(self, *args): return _mmut.Connectivity2_Superpose(self, *args)
    def MatchGraphs(self, *args): return _mmut.Connectivity2_MatchGraphs(self, *args)
Connectivity2_swigregister = _mmut.Connectivity2_swigregister
Connectivity2_swigregister(Connectivity2)

class CNABasePairs(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CNABasePairs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CNABasePairs, name)
    __repr__ = _swig_repr
    def Calculate(self, *args): return _mmut.CNABasePairs_Calculate(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_CNABasePairs(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetPairedResidue(self, *args): return _mmut.CNABasePairs_GetPairedResidue(self, *args)
    def GetPairedResidueIndex(self, *args): return _mmut.CNABasePairs_GetPairedResidueIndex(self, *args)
    def GetPairs(self): return _mmut.CNABasePairs_GetPairs(self)
    def GetColours(self): return _mmut.CNABasePairs_GetColours(self)
    __swig_destroy__ = _mmut.delete_CNABasePairs
    __del__ = lambda self : None;
CNABasePairs_swigregister = _mmut.CNABasePairs_swigregister
CNABasePairs_swigregister(CNABasePairs)

class MMUTLipid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMUTLipid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMUTLipid, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_MMUTLipid()
        try: self.this.append(this)
        except: self.this = this
    def AddTailCartesians(self, *args): return _mmut.MMUTLipid_AddTailCartesians(self, *args)
    def AddTailSerNums(self, *args): return _mmut.MMUTLipid_AddTailSerNums(self, *args)
    def AddTailHSerNums(self, *args): return _mmut.MMUTLipid_AddTailHSerNums(self, *args)
    def SetHeadCartesians(self, *args): return _mmut.MMUTLipid_SetHeadCartesians(self, *args)
    def SetHeadSerNums(self, *args): return _mmut.MMUTLipid_SetHeadSerNums(self, *args)
    def GetTailCartesians(self): return _mmut.MMUTLipid_GetTailCartesians(self)
    def GetHeadCartesians(self): return _mmut.MMUTLipid_GetHeadCartesians(self)
    def GetTailCartesian(self, *args): return _mmut.MMUTLipid_GetTailCartesian(self, *args)
    def GetHeadCartesian(self, *args): return _mmut.MMUTLipid_GetHeadCartesian(self, *args)
    def GetHeadSerNums(self, *args): return _mmut.MMUTLipid_GetHeadSerNums(self, *args)
    def GetTailSerNums(self, *args): return _mmut.MMUTLipid_GetTailSerNums(self, *args)
    def GetTailHSerNums(self, *args): return _mmut.MMUTLipid_GetTailHSerNums(self, *args)
    def GetMainSelectionHandle(self): return _mmut.MMUTLipid_GetMainSelectionHandle(self)
    def SetMainSelectionHandle(self, *args): return _mmut.MMUTLipid_SetMainSelectionHandle(self, *args)
    __swig_destroy__ = _mmut.delete_MMUTLipid
    __del__ = lambda self : None;
MMUTLipid_swigregister = _mmut.MMUTLipid_swigregister
MMUTLipid_swigregister(MMUTLipid)


def MMUTLipidCalculate(*args):
  return _mmut.MMUTLipidCalculate(*args)
MMUTLipidCalculate = _mmut.MMUTLipidCalculate

def MMUTLipidAnalyse(*args):
  return _mmut.MMUTLipidAnalyse(*args)
MMUTLipidAnalyse = _mmut.MMUTLipidAnalyse
class CMMUTMorph(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMUTMorph, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMMUTMorph, name)
    __repr__ = _swig_repr
    def MorphCartesians(self, *args): return _mmut.CMMUTMorph_MorphCartesians(self, *args)
    def MorphTrees(self, *args): return _mmut.CMMUTMorph_MorphTrees(self, *args)
    def __init__(self): 
        this = _mmut.new_CMMUTMorph()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_CMMUTMorph
    __del__ = lambda self : None;
CMMUTMorph_swigregister = _mmut.CMMUTMorph_swigregister
CMMUTMorph_swigregister(CMMUTMorph)

MMUT_ANM = _mmut.MMUT_ANM
MMUT_GNM = _mmut.MMUT_GNM
MMUT_NMA_NONE = _mmut.MMUT_NMA_NONE
class NormalModeDisplacements(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NormalModeDisplacements, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NormalModeDisplacements, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_NormalModeDisplacements()
        try: self.this.append(this)
        except: self.this = this
    def getDisplacements(self, *args): return _mmut.NormalModeDisplacements_getDisplacements(self, *args)
    def addMode(self): return _mmut.NormalModeDisplacements_addMode(self)
    def addDisplacements(self, *args): return _mmut.NormalModeDisplacements_addDisplacements(self, *args)
    def getNumberOfModes(self): return _mmut.NormalModeDisplacements_getNumberOfModes(self)
    def clear(self): return _mmut.NormalModeDisplacements_clear(self)
    __swig_destroy__ = _mmut.delete_NormalModeDisplacements
    __del__ = lambda self : None;
NormalModeDisplacements_swigregister = _mmut.NormalModeDisplacements_swigregister
NormalModeDisplacements_swigregister(NormalModeDisplacements)

class NormalModeAnalysis(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NormalModeAnalysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NormalModeAnalysis, name)
    __repr__ = _swig_repr
    def Calculate(self, *args): return _mmut.NormalModeAnalysis_Calculate(self, *args)
    def __init__(self, *args): 
        this = _mmut.new_NormalModeAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetEigen(self): return _mmut.NormalModeAnalysis_GetEigen(self)
    def GetDisplacements(self, *args): return _mmut.NormalModeAnalysis_GetDisplacements(self, *args)
    def GetHessian(self): return _mmut.NormalModeAnalysis_GetHessian(self)
    def GetInverseHessian(self): return _mmut.NormalModeAnalysis_GetInverseHessian(self)
    def GetDiagonalInverseHessian(self): return _mmut.NormalModeAnalysis_GetDiagonalInverseHessian(self)
    def StoreInverseHessian(self): return _mmut.NormalModeAnalysis_StoreInverseHessian(self)
    def GetType(self): return _mmut.NormalModeAnalysis_GetType(self)
    def GetBValues(self): return _mmut.NormalModeAnalysis_GetBValues(self)
    def GetModeShapes(self, gammainv=1.0): return _mmut.NormalModeAnalysis_GetModeShapes(self, gammainv)
    def GetModeShapesAsCartesians(self, *args): return _mmut.NormalModeAnalysis_GetModeShapesAsCartesians(self, *args)
    def GetCorrelations(self, *args): return _mmut.NormalModeAnalysis_GetCorrelations(self, *args)
    __swig_destroy__ = _mmut.delete_NormalModeAnalysis
    __del__ = lambda self : None;
NormalModeAnalysis_swigregister = _mmut.NormalModeAnalysis_swigregister
NormalModeAnalysis_swigregister(NormalModeAnalysis)

RESTYPE_PEPTIDE = _mmut.RESTYPE_PEPTIDE
RESTYPE_DPEPTIDE = _mmut.RESTYPE_DPEPTIDE
RESTYPE_LPEPTIDE = _mmut.RESTYPE_LPEPTIDE
RESTYPE_NUCL = _mmut.RESTYPE_NUCL
RESTYPE_DNA = _mmut.RESTYPE_DNA
RESTYPE_RNA = _mmut.RESTYPE_RNA
RESTYPE_SACH = _mmut.RESTYPE_SACH
RESTYPE_DSACH = _mmut.RESTYPE_DSACH
RESTYPE_LSACH = _mmut.RESTYPE_LSACH
RESTYPE_SOLVENT = _mmut.RESTYPE_SOLVENT
RESTYPE_SOLUTE = _mmut.RESTYPE_SOLUTE
RESTYPE_NONPOLY = _mmut.RESTYPE_NONPOLY
RESTYPE_PSEUDO = _mmut.RESTYPE_PSEUDO
RESTYPE_METAL = _mmut.RESTYPE_METAL
RESTYPE_UNKNOWN = _mmut.RESTYPE_UNKNOWN
CIFCAT_LIBATOM = _mmut.CIFCAT_LIBATOM
CIFTAG_LIBATOM_TYPE = _mmut.CIFTAG_LIBATOM_TYPE
CIFTAG_LIBATOM_WEIGHT = _mmut.CIFTAG_LIBATOM_WEIGHT
CIFTAG_LIBATOM_HBTYPE = _mmut.CIFTAG_LIBATOM_HBTYPE
CIFTAG_LIBATOM_VDWRAD = _mmut.CIFTAG_LIBATOM_VDWRAD
CIFTAG_LIBATOM_VDWHRAD = _mmut.CIFTAG_LIBATOM_VDWHRAD
CIFTAG_LIBATOM_IONRAD = _mmut.CIFTAG_LIBATOM_IONRAD
CIFTAG_LIBATOM_ELEMENT = _mmut.CIFTAG_LIBATOM_ELEMENT
CIFTAG_LIBATOM_VALENCY = _mmut.CIFTAG_LIBATOM_VALENCY
CIFTAG_LIBATOM_CHARGE = _mmut.CIFTAG_LIBATOM_CHARGE
class MMUTSRSAtomInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMUTSRSAtomInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MMUTSRSAtomInfo, name)
    __repr__ = _swig_repr
    def energy_type(self): return _mmut.MMUTSRSAtomInfo_energy_type(self)
    def vdw_radius(self): return _mmut.MMUTSRSAtomInfo_vdw_radius(self)
    def vdwh_radius(self): return _mmut.MMUTSRSAtomInfo_vdwh_radius(self)
    def ion_radius(self): return _mmut.MMUTSRSAtomInfo_ion_radius(self)
    def hb_type(self): return _mmut.MMUTSRSAtomInfo_hb_type(self)
    def set_energy_type(self, *args): return _mmut.MMUTSRSAtomInfo_set_energy_type(self, *args)
    def set_vdw_radius(self, *args): return _mmut.MMUTSRSAtomInfo_set_vdw_radius(self, *args)
    def set_vdwh_radius(self, *args): return _mmut.MMUTSRSAtomInfo_set_vdwh_radius(self, *args)
    def set_ion_radius(self, *args): return _mmut.MMUTSRSAtomInfo_set_ion_radius(self, *args)
    def set_hb_type(self, *args): return _mmut.MMUTSRSAtomInfo_set_hb_type(self, *args)
    def __init__(self): 
        this = _mmut.new_MMUTSRSAtomInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _mmut.delete_MMUTSRSAtomInfo
    __del__ = lambda self : None;
MMUTSRSAtomInfo_swigregister = _mmut.MMUTSRSAtomInfo_swigregister
MMUTSRSAtomInfo_swigregister(MMUTSRSAtomInfo)

class CMGCovalentDistance(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMGCovalentDistance, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMGCovalentDistance, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _mmut.new_CMGCovalentDistance(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetFirstAtom(self): return _mmut.CMGCovalentDistance_GetFirstAtom(self)
    def GetSecondAtom(self): return _mmut.CMGCovalentDistance_GetSecondAtom(self)
    def GetMinLength(self): return _mmut.CMGCovalentDistance_GetMinLength(self)
    def GetMaxLength(self): return _mmut.CMGCovalentDistance_GetMaxLength(self)
    __swig_destroy__ = _mmut.delete_CMGCovalentDistance
    __del__ = lambda self : None;
CMGCovalentDistance_swigregister = _mmut.CMGCovalentDistance_swigregister
CMGCovalentDistance_swigregister(CMGCovalentDistance)

class CMMUTSRS(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CMMUTSRS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CMMUTSRS, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _mmut.new_CMMUTSRS()
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["CheckCovalentDistance"] = lambda x: _mmut.CMMUTSRS_CheckCovalentDistance
    if _newclass:CheckCovalentDistance = staticmethod(_mmut.CMMUTSRS_CheckCovalentDistance)
    __swig_getmethods__["LoadCovalentDistances"] = lambda x: _mmut.CMMUTSRS_LoadCovalentDistances
    if _newclass:LoadCovalentDistances = staticmethod(_mmut.CMMUTSRS_LoadCovalentDistances)
    __swig_getmethods__["AddCovalentDistance"] = lambda x: _mmut.CMMUTSRS_AddCovalentDistance
    if _newclass:AddCovalentDistance = staticmethod(_mmut.CMMUTSRS_AddCovalentDistance)
    __swig_getmethods__["GetCharge"] = lambda x: _mmut.CMMUTSRS_GetCharge
    if _newclass:GetCharge = staticmethod(_mmut.CMMUTSRS_GetCharge)
    __swig_getmethods__["LoadEnerLib"] = lambda x: _mmut.CMMUTSRS_LoadEnerLib
    if _newclass:LoadEnerLib = staticmethod(_mmut.CMMUTSRS_LoadEnerLib)
    __swig_getmethods__["LoadEleLib"] = lambda x: _mmut.CMMUTSRS_LoadEleLib
    if _newclass:LoadEleLib = staticmethod(_mmut.CMMUTSRS_LoadEleLib)
    __swig_getmethods__["GetElement"] = lambda x: _mmut.CMMUTSRS_GetElement
    if _newclass:GetElement = staticmethod(_mmut.CMMUTSRS_GetElement)
    __swig_setmethods__["typeCharges"] = _mmut.CMMUTSRS_typeCharges_set
    __swig_getmethods__["typeCharges"] = _mmut.CMMUTSRS_typeCharges_get
    if _newclass:typeCharges = _swig_property(_mmut.CMMUTSRS_typeCharges_get, _mmut.CMMUTSRS_typeCharges_set)
    __swig_setmethods__["typeHBonds"] = _mmut.CMMUTSRS_typeHBonds_set
    __swig_getmethods__["typeHBonds"] = _mmut.CMMUTSRS_typeHBonds_get
    if _newclass:typeHBonds = _swig_property(_mmut.CMMUTSRS_typeHBonds_get, _mmut.CMMUTSRS_typeHBonds_set)
    __swig_setmethods__["defaultAtomType"] = _mmut.CMMUTSRS_defaultAtomType_set
    __swig_getmethods__["defaultAtomType"] = _mmut.CMMUTSRS_defaultAtomType_get
    if _newclass:defaultAtomType = _swig_property(_mmut.CMMUTSRS_defaultAtomType_get, _mmut.CMMUTSRS_defaultAtomType_set)
    __swig_destroy__ = _mmut.delete_CMMUTSRS
    __del__ = lambda self : None;
CMMUTSRS_swigregister = _mmut.CMMUTSRS_swigregister
CMMUTSRS_swigregister(CMMUTSRS)

def CMMUTSRS_CheckCovalentDistance(*args):
  return _mmut.CMMUTSRS_CheckCovalentDistance(*args)
CMMUTSRS_CheckCovalentDistance = _mmut.CMMUTSRS_CheckCovalentDistance

def CMMUTSRS_LoadCovalentDistances(*args):
  return _mmut.CMMUTSRS_LoadCovalentDistances(*args)
CMMUTSRS_LoadCovalentDistances = _mmut.CMMUTSRS_LoadCovalentDistances

def CMMUTSRS_AddCovalentDistance(*args):
  return _mmut.CMMUTSRS_AddCovalentDistance(*args)
CMMUTSRS_AddCovalentDistance = _mmut.CMMUTSRS_AddCovalentDistance

def CMMUTSRS_GetCharge(*args):
  return _mmut.CMMUTSRS_GetCharge(*args)
CMMUTSRS_GetCharge = _mmut.CMMUTSRS_GetCharge

def CMMUTSRS_LoadEnerLib(*args):
  return _mmut.CMMUTSRS_LoadEnerLib(*args)
CMMUTSRS_LoadEnerLib = _mmut.CMMUTSRS_LoadEnerLib

def CMMUTSRS_LoadEleLib(*args):
  return _mmut.CMMUTSRS_LoadEleLib(*args)
CMMUTSRS_LoadEleLib = _mmut.CMMUTSRS_LoadEleLib

def CMMUTSRS_GetElement(*args):
  return _mmut.CMMUTSRS_GetElement(*args)
CMMUTSRS_GetElement = _mmut.CMMUTSRS_GetElement


def SmilesToPDB(*args):
  return _mmut.SmilesToPDB(*args)
SmilesToPDB = _mmut.SmilesToPDB

def RDKitLoadFileToPDB(*args):
  return _mmut.RDKitLoadFileToPDB(*args)
RDKitLoadFileToPDB = _mmut.RDKitLoadFileToPDB

def RDKitAromaticityAnalyze(*args):
  return _mmut.RDKitAromaticityAnalyze(*args)
RDKitAromaticityAnalyze = _mmut.RDKitAromaticityAnalyze

def RDKitResidueToSVG(*args):
  return _mmut.RDKitResidueToSVG(*args)
RDKitResidueToSVG = _mmut.RDKitResidueToSVG
# This file is compatible with both classic and new-style classes.


