# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.6
#
# 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('_ccp4srs', [dirname(__file__)])
        except ImportError:
            import _ccp4srs
            return _ccp4srs
        if fp is not None:
            try:
                _mod = imp.load_module('_ccp4srs', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ccp4srs = swig_import_helper()
    del swig_import_helper
else:
    import _ccp4srs
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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__ = _ccp4srs.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _ccp4srs.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _ccp4srs.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _ccp4srs.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _ccp4srs.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _ccp4srs.SwigPyIterator_equal(self, x)

    def copy(self):
        return _ccp4srs.SwigPyIterator_copy(self)

    def next(self):
        return _ccp4srs.SwigPyIterator_next(self)

    def __next__(self):
        return _ccp4srs.SwigPyIterator___next__(self)

    def previous(self):
        return _ccp4srs.SwigPyIterator_previous(self)

    def advance(self, n):
        return _ccp4srs.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _ccp4srs.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _ccp4srs.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _ccp4srs.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _ccp4srs.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _ccp4srs.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _ccp4srs.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _ccp4srs.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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 _ccp4srs.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ccp4srs.IntVector___nonzero__(self)

    def __bool__(self):
        return _ccp4srs.IntVector___bool__(self)

    def __len__(self):
        return _ccp4srs.IntVector___len__(self)

    def pop(self):
        return _ccp4srs.IntVector_pop(self)

    def __getslice__(self, i, j):
        return _ccp4srs.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ccp4srs.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ccp4srs.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ccp4srs.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ccp4srs.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ccp4srs.IntVector___setitem__(self, *args)

    def append(self, x):
        return _ccp4srs.IntVector_append(self, x)

    def empty(self):
        return _ccp4srs.IntVector_empty(self)

    def size(self):
        return _ccp4srs.IntVector_size(self)

    def clear(self):
        return _ccp4srs.IntVector_clear(self)

    def swap(self, v):
        return _ccp4srs.IntVector_swap(self, v)

    def get_allocator(self):
        return _ccp4srs.IntVector_get_allocator(self)

    def begin(self):
        return _ccp4srs.IntVector_begin(self)

    def end(self):
        return _ccp4srs.IntVector_end(self)

    def rbegin(self):
        return _ccp4srs.IntVector_rbegin(self)

    def rend(self):
        return _ccp4srs.IntVector_rend(self)

    def pop_back(self):
        return _ccp4srs.IntVector_pop_back(self)

    def erase(self, *args):
        return _ccp4srs.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _ccp4srs.new_IntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _ccp4srs.IntVector_push_back(self, x)

    def front(self):
        return _ccp4srs.IntVector_front(self)

    def back(self):
        return _ccp4srs.IntVector_back(self)

    def assign(self, n, x):
        return _ccp4srs.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _ccp4srs.IntVector_resize(self, *args)

    def insert(self, *args):
        return _ccp4srs.IntVector_insert(self, *args)

    def reserve(self, n):
        return _ccp4srs.IntVector_reserve(self, n)

    def capacity(self):
        return _ccp4srs.IntVector_capacity(self)
    __swig_destroy__ = _ccp4srs.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _ccp4srs.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 _ccp4srs.IntIntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ccp4srs.IntIntVector___nonzero__(self)

    def __bool__(self):
        return _ccp4srs.IntIntVector___bool__(self)

    def __len__(self):
        return _ccp4srs.IntIntVector___len__(self)

    def pop(self):
        return _ccp4srs.IntIntVector_pop(self)

    def __getslice__(self, i, j):
        return _ccp4srs.IntIntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ccp4srs.IntIntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ccp4srs.IntIntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ccp4srs.IntIntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ccp4srs.IntIntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ccp4srs.IntIntVector___setitem__(self, *args)

    def append(self, x):
        return _ccp4srs.IntIntVector_append(self, x)

    def empty(self):
        return _ccp4srs.IntIntVector_empty(self)

    def size(self):
        return _ccp4srs.IntIntVector_size(self)

    def clear(self):
        return _ccp4srs.IntIntVector_clear(self)

    def swap(self, v):
        return _ccp4srs.IntIntVector_swap(self, v)

    def get_allocator(self):
        return _ccp4srs.IntIntVector_get_allocator(self)

    def begin(self):
        return _ccp4srs.IntIntVector_begin(self)

    def end(self):
        return _ccp4srs.IntIntVector_end(self)

    def rbegin(self):
        return _ccp4srs.IntIntVector_rbegin(self)

    def rend(self):
        return _ccp4srs.IntIntVector_rend(self)

    def pop_back(self):
        return _ccp4srs.IntIntVector_pop_back(self)

    def erase(self, *args):
        return _ccp4srs.IntIntVector_erase(self, *args)

    def __init__(self, *args):
        this = _ccp4srs.new_IntIntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _ccp4srs.IntIntVector_push_back(self, x)

    def front(self):
        return _ccp4srs.IntIntVector_front(self)

    def back(self):
        return _ccp4srs.IntIntVector_back(self)

    def assign(self, n, x):
        return _ccp4srs.IntIntVector_assign(self, n, x)

    def resize(self, *args):
        return _ccp4srs.IntIntVector_resize(self, *args)

    def insert(self, *args):
        return _ccp4srs.IntIntVector_insert(self, *args)

    def reserve(self, n):
        return _ccp4srs.IntIntVector_reserve(self, n)

    def capacity(self):
        return _ccp4srs.IntIntVector_capacity(self)
    __swig_destroy__ = _ccp4srs.delete_IntIntVector
    __del__ = lambda self: None
IntIntVector_swigregister = _ccp4srs.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 _ccp4srs.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ccp4srs.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _ccp4srs.DoubleVector___bool__(self)

    def __len__(self):
        return _ccp4srs.DoubleVector___len__(self)

    def pop(self):
        return _ccp4srs.DoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _ccp4srs.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ccp4srs.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ccp4srs.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ccp4srs.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ccp4srs.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ccp4srs.DoubleVector___setitem__(self, *args)

    def append(self, x):
        return _ccp4srs.DoubleVector_append(self, x)

    def empty(self):
        return _ccp4srs.DoubleVector_empty(self)

    def size(self):
        return _ccp4srs.DoubleVector_size(self)

    def clear(self):
        return _ccp4srs.DoubleVector_clear(self)

    def swap(self, v):
        return _ccp4srs.DoubleVector_swap(self, v)

    def get_allocator(self):
        return _ccp4srs.DoubleVector_get_allocator(self)

    def begin(self):
        return _ccp4srs.DoubleVector_begin(self)

    def end(self):
        return _ccp4srs.DoubleVector_end(self)

    def rbegin(self):
        return _ccp4srs.DoubleVector_rbegin(self)

    def rend(self):
        return _ccp4srs.DoubleVector_rend(self)

    def pop_back(self):
        return _ccp4srs.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _ccp4srs.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _ccp4srs.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _ccp4srs.DoubleVector_push_back(self, x)

    def front(self):
        return _ccp4srs.DoubleVector_front(self)

    def back(self):
        return _ccp4srs.DoubleVector_back(self)

    def assign(self, n, x):
        return _ccp4srs.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _ccp4srs.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _ccp4srs.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _ccp4srs.DoubleVector_reserve(self, n)

    def capacity(self):
        return _ccp4srs.DoubleVector_capacity(self)
    __swig_destroy__ = _ccp4srs.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _ccp4srs.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 _ccp4srs.DoubleDoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ccp4srs.DoubleDoubleVector___nonzero__(self)

    def __bool__(self):
        return _ccp4srs.DoubleDoubleVector___bool__(self)

    def __len__(self):
        return _ccp4srs.DoubleDoubleVector___len__(self)

    def pop(self):
        return _ccp4srs.DoubleDoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _ccp4srs.DoubleDoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ccp4srs.DoubleDoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ccp4srs.DoubleDoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ccp4srs.DoubleDoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ccp4srs.DoubleDoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ccp4srs.DoubleDoubleVector___setitem__(self, *args)

    def append(self, x):
        return _ccp4srs.DoubleDoubleVector_append(self, x)

    def empty(self):
        return _ccp4srs.DoubleDoubleVector_empty(self)

    def size(self):
        return _ccp4srs.DoubleDoubleVector_size(self)

    def clear(self):
        return _ccp4srs.DoubleDoubleVector_clear(self)

    def swap(self, v):
        return _ccp4srs.DoubleDoubleVector_swap(self, v)

    def get_allocator(self):
        return _ccp4srs.DoubleDoubleVector_get_allocator(self)

    def begin(self):
        return _ccp4srs.DoubleDoubleVector_begin(self)

    def end(self):
        return _ccp4srs.DoubleDoubleVector_end(self)

    def rbegin(self):
        return _ccp4srs.DoubleDoubleVector_rbegin(self)

    def rend(self):
        return _ccp4srs.DoubleDoubleVector_rend(self)

    def pop_back(self):
        return _ccp4srs.DoubleDoubleVector_pop_back(self)

    def erase(self, *args):
        return _ccp4srs.DoubleDoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _ccp4srs.new_DoubleDoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _ccp4srs.DoubleDoubleVector_push_back(self, x)

    def front(self):
        return _ccp4srs.DoubleDoubleVector_front(self)

    def back(self):
        return _ccp4srs.DoubleDoubleVector_back(self)

    def assign(self, n, x):
        return _ccp4srs.DoubleDoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _ccp4srs.DoubleDoubleVector_resize(self, *args)

    def insert(self, *args):
        return _ccp4srs.DoubleDoubleVector_insert(self, *args)

    def reserve(self, n):
        return _ccp4srs.DoubleDoubleVector_reserve(self, n)

    def capacity(self):
        return _ccp4srs.DoubleDoubleVector_capacity(self)
    __swig_destroy__ = _ccp4srs.delete_DoubleDoubleVector
    __del__ = lambda self: None
DoubleDoubleVector_swigregister = _ccp4srs.DoubleDoubleVector_swigregister
DoubleDoubleVector_swigregister(DoubleDoubleVector)


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

def mround(X):
    return _ccp4srs.mround(X)
mround = _ccp4srs.mround

def ifloor(X):
    return _ccp4srs.ifloor(X)
ifloor = _ccp4srs.ifloor

def Abs(x):
    return _ccp4srs.Abs(x)
Abs = _ccp4srs.Abs

def ISwap(x, y):
    return _ccp4srs.ISwap(x, y)
ISwap = _ccp4srs.ISwap

def WSwap(x, y):
    return _ccp4srs.WSwap(x, y)
WSwap = _ccp4srs.WSwap

def BSwap(x, y):
    return _ccp4srs.BSwap(x, y)
BSwap = _ccp4srs.BSwap

def OSwap(x, y):
    return _ccp4srs.OSwap(x, y)
OSwap = _ccp4srs.OSwap

def LSwap(x, y):
    return _ccp4srs.LSwap(x, y)
LSwap = _ccp4srs.LSwap

def RSwap(x, y):
    return _ccp4srs.RSwap(x, y)
RSwap = _ccp4srs.RSwap

def RMax(x1, x2):
    return _ccp4srs.RMax(x1, x2)
RMax = _ccp4srs.RMax

def LMax(x1, x2):
    return _ccp4srs.LMax(x1, x2)
LMax = _ccp4srs.LMax

def WMax(x1, x2):
    return _ccp4srs.WMax(x1, x2)
WMax = _ccp4srs.WMax

def IMax(x1, x2):
    return _ccp4srs.IMax(x1, x2)
IMax = _ccp4srs.IMax

def RMin(x1, x2):
    return _ccp4srs.RMin(x1, x2)
RMin = _ccp4srs.RMin

def LMin(x1, x2):
    return _ccp4srs.LMin(x1, x2)
LMin = _ccp4srs.LMin

def WMin(x1, x2):
    return _ccp4srs.WMin(x1, x2)
WMin = _ccp4srs.WMin

def IMin(x1, x2):
    return _ccp4srs.IMin(x1, x2)
IMin = _ccp4srs.IMin

def fsign(x1, x2):
    return _ccp4srs.fsign(x1, x2)
fsign = _ccp4srs.fsign

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

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

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

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

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

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

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

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

def frac(R):
    return _ccp4srs.frac(R)
frac = _ccp4srs.frac

def mod(x, y):
    return _ccp4srs.mod(x, y)
mod = _ccp4srs.mod

def Pow(X, y):
    return _ccp4srs.Pow(X, y)
Pow = _ccp4srs.Pow

def Pow1(X, Y):
    return _ccp4srs.Pow1(X, Y)
Pow1 = _ccp4srs.Pow1

def Exp(X):
    return _ccp4srs.Exp(X)
Exp = _ccp4srs.Exp

def Odd(i):
    return _ccp4srs.Odd(i)
Odd = _ccp4srs.Odd

def HexValL(S):
    return _ccp4srs.HexValL(S)
HexValL = _ccp4srs.HexValL

def OctValL(S):
    return _ccp4srs.OctValL(S)
OctValL = _ccp4srs.OctValL

def BinValL(S):
    return _ccp4srs.BinValL(S)
BinValL = _ccp4srs.BinValL

def BinValS(L, S):
    return _ccp4srs.BinValS(L, S)
BinValS = _ccp4srs.BinValS

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

def CreateCopy(Dest, Source):
    return _ccp4srs.CreateCopy(Dest, Source)
CreateCopy = _ccp4srs.CreateCopy

def CreateCopy_n(Dest, Source, n):
    return _ccp4srs.CreateCopy_n(Dest, Source, n)
CreateCopy_n = _ccp4srs.CreateCopy_n

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

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

def LastOccurence(S, c):
    return _ccp4srs.LastOccurence(S, c)
LastOccurence = _ccp4srs.LastOccurence

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

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

def LowerCase(s):
    return _ccp4srs.LowerCase(s)
LowerCase = _ccp4srs.LowerCase

def UpperCase(s):
    return _ccp4srs.UpperCase(s)
UpperCase = _ccp4srs.UpperCase

def GetString(L, S, M):
    return _ccp4srs.GetString(L, S, M)
GetString = _ccp4srs.GetString

def GetStrTer(L, S, n, LMax, SMax):
    return _ccp4srs.GetStrTer(L, S, n, LMax, SMax)
GetStrTer = _ccp4srs.GetStrTer

def GetStrTerWin32File(L, S, n, LMax, SMax):
    return _ccp4srs.GetStrTerWin32File(L, S, n, LMax, SMax)
GetStrTerWin32File = _ccp4srs.GetStrTerWin32File

def strcpy_n(d, s, n):
    return _ccp4srs.strcpy_n(d, s, n)
strcpy_n = _ccp4srs.strcpy_n

def strcpy_n1(d, s, n):
    return _ccp4srs.strcpy_n1(d, s, n)
strcpy_n1 = _ccp4srs.strcpy_n1

def strcpy_nr(d, s, n):
    return _ccp4srs.strcpy_nr(d, s, n)
strcpy_nr = _ccp4srs.strcpy_nr

def strcpy_ns(d, s, n):
    return _ccp4srs.strcpy_ns(d, s, n)
strcpy_ns = _ccp4srs.strcpy_ns

def strcpy_cs(d, s):
    return _ccp4srs.strcpy_cs(d, s)
strcpy_cs = _ccp4srs.strcpy_cs

def strcpy_ncs(d, s, n):
    return _ccp4srs.strcpy_ncs(d, s, n)
strcpy_ncs = _ccp4srs.strcpy_ncs

def strcpy_css(d, s):
    return _ccp4srs.strcpy_css(d, s)
strcpy_css = _ccp4srs.strcpy_css

def strcpy_ncss(d, s, n):
    return _ccp4srs.strcpy_ncss(d, s, n)
strcpy_ncss = _ccp4srs.strcpy_ncss

def strcpy_n0(d, s, n):
    return _ccp4srs.strcpy_n0(d, s, n)
strcpy_n0 = _ccp4srs.strcpy_n0

def strlen_des(s):
    return _ccp4srs.strlen_des(s)
strlen_des = _ccp4srs.strlen_des

def strcpy_des(d, s):
    return _ccp4srs.strcpy_des(d, s)
strcpy_des = _ccp4srs.strcpy_des

def strcat_des(d, s):
    return _ccp4srs.strcat_des(d, s)
strcat_des = _ccp4srs.strcat_des

def PadSpaces(S, len):
    return _ccp4srs.PadSpaces(S, len)
PadSpaces = _ccp4srs.PadSpaces

_ccp4srs.SCUTKEY_BEGIN_swigconstant(_ccp4srs)
SCUTKEY_BEGIN = _ccp4srs.SCUTKEY_BEGIN

_ccp4srs.SCUTKEY_END_swigconstant(_ccp4srs)
SCUTKEY_END = _ccp4srs.SCUTKEY_END

_ccp4srs.SCUTKEY_BEGEND_swigconstant(_ccp4srs)
SCUTKEY_BEGEND = _ccp4srs.SCUTKEY_BEGEND

def CutSpaces(S, CutKey):
    return _ccp4srs.CutSpaces(S, CutKey)
CutSpaces = _ccp4srs.CutSpaces

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

def EnforceSpaces(S):
    return _ccp4srs.EnforceSpaces(S)
EnforceSpaces = _ccp4srs.EnforceSpaces

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

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

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

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

def int2UniBin(I, iUB):
    return _ccp4srs.int2UniBin(I, iUB)
int2UniBin = _ccp4srs.int2UniBin

def short2UniBin(S, sUB):
    return _ccp4srs.short2UniBin(S, sUB)
short2UniBin = _ccp4srs.short2UniBin

def long2UniBin(L, lUB):
    return _ccp4srs.long2UniBin(L, lUB)
long2UniBin = _ccp4srs.long2UniBin

def word2UniBin(W, wUB):
    return _ccp4srs.word2UniBin(W, wUB)
word2UniBin = _ccp4srs.word2UniBin

def real2UniBin(R, rUB):
    return _ccp4srs.real2UniBin(R, rUB)
real2UniBin = _ccp4srs.real2UniBin

def float2UniBin(R, fUB):
    return _ccp4srs.float2UniBin(R, fUB)
float2UniBin = _ccp4srs.float2UniBin

def shortreal2UniBin(R, srUB):
    return _ccp4srs.shortreal2UniBin(R, srUB)
shortreal2UniBin = _ccp4srs.shortreal2UniBin

def UniBin2int(iUB, I):
    return _ccp4srs.UniBin2int(iUB, I)
UniBin2int = _ccp4srs.UniBin2int

def UniBin2short(sUB, S):
    return _ccp4srs.UniBin2short(sUB, S)
UniBin2short = _ccp4srs.UniBin2short

def UniBin2long(lUB, L):
    return _ccp4srs.UniBin2long(lUB, L)
UniBin2long = _ccp4srs.UniBin2long

def UniBin2word(wUB, W):
    return _ccp4srs.UniBin2word(wUB, W)
UniBin2word = _ccp4srs.UniBin2word

def UniBin2real(rUB, R):
    return _ccp4srs.UniBin2real(rUB, R)
UniBin2real = _ccp4srs.UniBin2real

def UniBin2shortreal(srUB, R):
    return _ccp4srs.UniBin2shortreal(srUB, R)
UniBin2shortreal = _ccp4srs.UniBin2shortreal

def UniBin2float(fUB, R):
    return _ccp4srs.UniBin2float(fUB, R)
UniBin2float = _ccp4srs.UniBin2float

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

def mem_write_byte(B, S, l):
    return _ccp4srs.mem_write_byte(B, S, l)
mem_write_byte = _ccp4srs.mem_write_byte

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

def mem_read_byte(B, S, l):
    return _ccp4srs.mem_read_byte(B, S, l)
mem_read_byte = _ccp4srs.mem_read_byte

_ccp4srs.GZM_NONE_swigconstant(_ccp4srs)
GZM_NONE = _ccp4srs.GZM_NONE

_ccp4srs.GZM_CHECK_swigconstant(_ccp4srs)
GZM_CHECK = _ccp4srs.GZM_CHECK

_ccp4srs.GZM_ENFORCE_swigconstant(_ccp4srs)
GZM_ENFORCE = _ccp4srs.GZM_ENFORCE

_ccp4srs.GZM_ENFORCE_GZIP_swigconstant(_ccp4srs)
GZM_ENFORCE_GZIP = _ccp4srs.GZM_ENFORCE_GZIP

_ccp4srs.GZM_ENFORCE_COMPRESS_swigconstant(_ccp4srs)
GZM_ENFORCE_COMPRESS = _ccp4srs.GZM_ENFORCE_COMPRESS

_ccp4srs.FileError_NoMemory_swigconstant(_ccp4srs)
FileError_NoMemory = _ccp4srs.FileError_NoMemory

_ccp4srs.FileError_ShortData_swigconstant(_ccp4srs)
FileError_ShortData = _ccp4srs.FileError_ShortData

_ccp4srs.FileError_NoDataFound_swigconstant(_ccp4srs)
FileError_NoDataFound = _ccp4srs.FileError_NoDataFound

_ccp4srs.FileError_NoColumn_swigconstant(_ccp4srs)
FileError_NoColumn = _ccp4srs.FileError_NoColumn

_ccp4srs.FileError_BadData_swigconstant(_ccp4srs)
FileError_BadData = _ccp4srs.FileError_BadData

_ccp4srs.FileError_WrongMemoryAllocation_swigconstant(_ccp4srs)
FileError_WrongMemoryAllocation = _ccp4srs.FileError_WrongMemoryAllocation

_ccp4srs.syskey_unix_swigconstant(_ccp4srs)
syskey_unix = _ccp4srs.syskey_unix

_ccp4srs.syskey_win_swigconstant(_ccp4srs)
syskey_win = _ccp4srs.syskey_win

_ccp4srs.syskey_all_swigconstant(_ccp4srs)
syskey_all = _ccp4srs.syskey_all

def GetFPath(*args):
    return _ccp4srs.GetFPath(*args)
GetFPath = _ccp4srs.GetFPath

def GetFName(*args):
    return _ccp4srs.GetFName(*args)
GetFName = _ccp4srs.GetFName

def GetFExt(FilePath):
    return _ccp4srs.GetFExt(FilePath)
GetFExt = _ccp4srs.GetFExt

def ChangeExt(*args):
    return _ccp4srs.ChangeExt(*args)
ChangeExt = _ccp4srs.ChangeExt

def FileError(ErrCode):
    return _ccp4srs.FileError(ErrCode)
FileError = _ccp4srs.FileError

def RemoveDelimiters(S, SLen):
    return _ccp4srs.RemoveDelimiters(S, SLen)
RemoveDelimiters = _ccp4srs.RemoveDelimiters

def PickOutNumber(S, SV, SLen, j):
    return _ccp4srs.PickOutNumber(S, SV, SLen, j)
PickOutNumber = _ccp4srs.PickOutNumber
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

    def __init__(self, BufSize=4096):
        this = _ccp4srs.new_File(BufSize)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_File
    __del__ = lambda self: None

    def assign(self, *args):
        return _ccp4srs.File_assign(self, *args)

    def takeFilePool(self, filePool, fileSize):
        return _ccp4srs.File_takeFilePool(self, filePool, fileSize)

    def GetFilePool(self, filePool, fileSize):
        return _ccp4srs.File_GetFilePool(self, filePool, fileSize)

    def FileName(self):
        return _ccp4srs.File_FileName(self)

    def truncate(self, size):
        return _ccp4srs.File_truncate(self, size)

    def reset(self, ReadOnly=False, retry=0):
        return _ccp4srs.File_reset(self, ReadOnly, retry)

    def erase(self):
        return _ccp4srs.File_erase(self)

    def exists(self):
        return _ccp4srs.File_exists(self)

    def parse(self, FileName):
        return _ccp4srs.File_parse(self, FileName)

    def rename(self, NewFileName):
        return _ccp4srs.File_rename(self, NewFileName)

    def rewrite(self):
        return _ccp4srs.File_rewrite(self)

    def append(self):
        return _ccp4srs.File_append(self)

    def isOpen(self):
        return _ccp4srs.File_isOpen(self)

    def Position(self):
        return _ccp4srs.File_Position(self)

    def FileLength(self):
        return _ccp4srs.File_FileLength(self)

    def seek(self, Position):
        return _ccp4srs.File_seek(self, Position)

    def FileEnd(self):
        return _ccp4srs.File_FileEnd(self)

    def Success(self):
        return _ccp4srs.File_Success(self)

    def SetSuccess(self):
        return _ccp4srs.File_SetSuccess(self)

    def flush(self):
        return _ccp4srs.File_flush(self)

    def shut(self):
        return _ccp4srs.File_shut(self)

    def ReadFile(self, Buffer, Count):
        return _ccp4srs.File_ReadFile(self, Buffer, Count)

    def CreateRead(self, Line):
        return _ccp4srs.File_CreateRead(self, Line)

    def ReadTerLine(self, Line, longLine=False):
        return _ccp4srs.File_ReadTerLine(self, Line, longLine)

    def WriteFile(self, Buffer, Count):
        return _ccp4srs.File_WriteFile(self, Buffer, Count)

    def CreateWrite(self, Line):
        return _ccp4srs.File_CreateWrite(self, Line)

    def WriteTerLine(self, Line, longLine=False):
        return _ccp4srs.File_WriteTerLine(self, Line, longLine)

    def WriteReal(self, V):
        return _ccp4srs.File_WriteReal(self, V)

    def WriteFloat(self, V):
        return _ccp4srs.File_WriteFloat(self, V)

    def WriteInt(self, I):
        return _ccp4srs.File_WriteInt(self, I)

    def WriteShort(self, S):
        return _ccp4srs.File_WriteShort(self, S)

    def WriteLong(self, L):
        return _ccp4srs.File_WriteLong(self, L)

    def WriteBool(self, B):
        return _ccp4srs.File_WriteBool(self, B)

    def WriteByte(self, B):
        return _ccp4srs.File_WriteByte(self, B)

    def WriteWord(self, W):
        return _ccp4srs.File_WriteWord(self, W)

    def ReadReal(self, V):
        return _ccp4srs.File_ReadReal(self, V)

    def ReadFloat(self, V):
        return _ccp4srs.File_ReadFloat(self, V)

    def ReadInt(self, I):
        return _ccp4srs.File_ReadInt(self, I)

    def ReadShort(self, S):
        return _ccp4srs.File_ReadShort(self, S)

    def ReadLong(self, L):
        return _ccp4srs.File_ReadLong(self, L)

    def ReadBool(self, B):
        return _ccp4srs.File_ReadBool(self, B)

    def ReadByte(self, B):
        return _ccp4srs.File_ReadByte(self, B)

    def ReadWord(self, B):
        return _ccp4srs.File_ReadWord(self, B)

    def AddReal(self, V):
        return _ccp4srs.File_AddReal(self, V)

    def AddFloat(self, V):
        return _ccp4srs.File_AddFloat(self, V)

    def AddInt(self, I):
        return _ccp4srs.File_AddInt(self, I)

    def AddShort(self, S):
        return _ccp4srs.File_AddShort(self, S)

    def AddLong(self, L):
        return _ccp4srs.File_AddLong(self, L)

    def AddByte(self, B):
        return _ccp4srs.File_AddByte(self, B)

    def AddWord(self, B):
        return _ccp4srs.File_AddWord(self, B)

    def WriteVector(self, *args):
        return _ccp4srs.File_WriteVector(self, *args)

    def ReadVector(self, *args):
        return _ccp4srs.File_ReadVector(self, *args)

    def CreateReadVector(self, *args):
        return _ccp4srs.File_CreateReadVector(self, *args)

    def WriteMatrix(self, A, N, M, ShiftN, ShiftM):
        return _ccp4srs.File_WriteMatrix(self, A, N, M, ShiftN, ShiftM)

    def CreateReadMatrix(self, *args):
        return _ccp4srs.File_CreateReadMatrix(self, *args)

    def Write(self, *args):
        return _ccp4srs.File_Write(self, *args)

    def WriteLine(self, Line):
        return _ccp4srs.File_WriteLine(self, Line)

    def LF(self):
        return _ccp4srs.File_LF(self)

    def ReadLine(self, Line, MaxLen=255):
        return _ccp4srs.File_ReadLine(self, Line, MaxLen)

    def ReadNonBlankLine(self, S, MaxLen=255):
        return _ccp4srs.File_ReadNonBlankLine(self, S, MaxLen)

    def WriteDataLine(self, X, Y, length=10):
        return _ccp4srs.File_WriteDataLine(self, X, Y, length)

    def WriteParameter(self, S, X, ParColumn=40, length=10):
        return _ccp4srs.File_WriteParameter(self, S, X, ParColumn, length)

    def WriteParameters(self, S, n_X, X, ParColumn=40, length=10):
        return _ccp4srs.File_WriteParameters(self, S, n_X, X, ParColumn, length)

    def ReadParameter(self, *args):
        return _ccp4srs.File_ReadParameter(self, *args)

    def ReadParameters(self, S, n_X, X, MaxLen=255, ParColumn=40):
        return _ccp4srs.File_ReadParameters(self, S, n_X, X, MaxLen, ParColumn)

    def WriteColumns(self, *args):
        return _ccp4srs.File_WriteColumns(self, *args)

    def ReadColumns(self, *args):
        return _ccp4srs.File_ReadColumns(self, *args)

    def CreateReadColumns(self, *args):
        return _ccp4srs.File_CreateReadColumns(self, *args)

    def GetNumber(self, S):
        return _ccp4srs.File_GetNumber(self, S)

    def GetHandle(self):
        return _ccp4srs.File_GetHandle(self)
File_swigregister = _ccp4srs.File_swigregister
File_swigregister(File)
cvar = _ccp4srs.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
_dir_sep_c = cvar._dir_sep_c


def SetGZIPPath(gzipPath, ungzipPath):
    return _ccp4srs.SetGZIPPath(gzipPath, ungzipPath)
SetGZIPPath = _ccp4srs.SetGZIPPath

def SetCompressPath(compressPath, uncompressPath):
    return _ccp4srs.SetCompressPath(compressPath, uncompressPath)
SetCompressPath = _ccp4srs.SetCompressPath

def FileExists(FileName, f=None):
    return _ccp4srs.FileExists(FileName, f)
FileExists = _ccp4srs.FileExists

_ccp4srs.MAJOR_VERSION_swigconstant(_ccp4srs)
MAJOR_VERSION = _ccp4srs.MAJOR_VERSION

_ccp4srs.MINOR_VERSION_swigconstant(_ccp4srs)
MINOR_VERSION = _ccp4srs.MINOR_VERSION

_ccp4srs.MICRO_VERSION_swigconstant(_ccp4srs)
MICRO_VERSION = _ccp4srs.MICRO_VERSION

_ccp4srs.CCP4SRS_noDonors_swigconstant(_ccp4srs)
CCP4SRS_noDonors = _ccp4srs.CCP4SRS_noDonors

_ccp4srs.CCP4SRS_noAcceptors_swigconstant(_ccp4srs)
CCP4SRS_noAcceptors = _ccp4srs.CCP4SRS_noAcceptors

_ccp4srs.CCP4SRS_noHBonds_swigconstant(_ccp4srs)
CCP4SRS_noHBonds = _ccp4srs.CCP4SRS_noHBonds

_ccp4srs.CCP4SRS_Incomplete_swigconstant(_ccp4srs)
CCP4SRS_Incomplete = _ccp4srs.CCP4SRS_Incomplete

_ccp4srs.CCP4SRS_Ok_swigconstant(_ccp4srs)
CCP4SRS_Ok = _ccp4srs.CCP4SRS_Ok

_ccp4srs.CCP4SRS_WrongBondType_swigconstant(_ccp4srs)
CCP4SRS_WrongBondType = _ccp4srs.CCP4SRS_WrongBondType

_ccp4srs.CCP4SRS_IndexCorrupt_swigconstant(_ccp4srs)
CCP4SRS_IndexCorrupt = _ccp4srs.CCP4SRS_IndexCorrupt

_ccp4srs.CCP4SRS_FileNotFound_swigconstant(_ccp4srs)
CCP4SRS_FileNotFound = _ccp4srs.CCP4SRS_FileNotFound

_ccp4srs.CCP4SRS_EntryNotFound_swigconstant(_ccp4srs)
CCP4SRS_EntryNotFound = _ccp4srs.CCP4SRS_EntryNotFound

_ccp4srs.CCP4SRS_ReadErrors_swigconstant(_ccp4srs)
CCP4SRS_ReadErrors = _ccp4srs.CCP4SRS_ReadErrors

_ccp4srs.CCP4SRS_EmptyResidue_swigconstant(_ccp4srs)
CCP4SRS_EmptyResidue = _ccp4srs.CCP4SRS_EmptyResidue

_ccp4srs.CCP4SRS_NoAtomsFound_swigconstant(_ccp4srs)
CCP4SRS_NoAtomsFound = _ccp4srs.CCP4SRS_NoAtomsFound

_ccp4srs.CCP4SRS_NoBonds_swigconstant(_ccp4srs)
CCP4SRS_NoBonds = _ccp4srs.CCP4SRS_NoBonds

_ccp4srs.CCP4SRS_EmptyResSet_swigconstant(_ccp4srs)
CCP4SRS_EmptyResSet = _ccp4srs.CCP4SRS_EmptyResSet

_ccp4srs.CCP4SRS_Fail_swigconstant(_ccp4srs)
CCP4SRS_Fail = _ccp4srs.CCP4SRS_Fail

_ccp4srs.CCP4SRS_SVD_Fail_swigconstant(_ccp4srs)
CCP4SRS_SVD_Fail = _ccp4srs.CCP4SRS_SVD_Fail

_ccp4srs.CCP4SRS_noCoordHierarchy_swigconstant(_ccp4srs)
CCP4SRS_noCoordHierarchy = _ccp4srs.CCP4SRS_noCoordHierarchy

_ccp4srs.CCP4SRS_BrokenBonds_swigconstant(_ccp4srs)
CCP4SRS_BrokenBonds = _ccp4srs.CCP4SRS_BrokenBonds
class AtomPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtomPair, name)
    __repr__ = _swig_repr
    __swig_setmethods__["a1"] = _ccp4srs.AtomPair_a1_set
    __swig_getmethods__["a1"] = _ccp4srs.AtomPair_a1_get
    if _newclass:
        a1 = _swig_property(_ccp4srs.AtomPair_a1_get, _ccp4srs.AtomPair_a1_set)
    __swig_setmethods__["a2"] = _ccp4srs.AtomPair_a2_set
    __swig_getmethods__["a2"] = _ccp4srs.AtomPair_a2_get
    if _newclass:
        a2 = _swig_property(_ccp4srs.AtomPair_a2_get, _ccp4srs.AtomPair_a2_set)

    def __init__(self):
        this = _ccp4srs.new_AtomPair()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_AtomPair
    __del__ = lambda self: None
AtomPair_swigregister = _ccp4srs.AtomPair_swigregister
AtomPair_swigregister(AtomPair)
CCP4SRS_file_version = cvar.CCP4SRS_file_version
AtomID_NA = cvar.AtomID_NA

class DASelHnds(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DASelHnds, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DASelHnds, name)
    __repr__ = _swig_repr
    __swig_setmethods__["selHndDonor"] = _ccp4srs.DASelHnds_selHndDonor_set
    __swig_getmethods__["selHndDonor"] = _ccp4srs.DASelHnds_selHndDonor_get
    if _newclass:
        selHndDonor = _swig_property(_ccp4srs.DASelHnds_selHndDonor_get, _ccp4srs.DASelHnds_selHndDonor_set)
    __swig_setmethods__["selHndAcceptor"] = _ccp4srs.DASelHnds_selHndAcceptor_set
    __swig_getmethods__["selHndAcceptor"] = _ccp4srs.DASelHnds_selHndAcceptor_get
    if _newclass:
        selHndAcceptor = _swig_property(_ccp4srs.DASelHnds_selHndAcceptor_get, _ccp4srs.DASelHnds_selHndAcceptor_set)
    __swig_setmethods__["selHndHydrogen"] = _ccp4srs.DASelHnds_selHndHydrogen_set
    __swig_getmethods__["selHndHydrogen"] = _ccp4srs.DASelHnds_selHndHydrogen_get
    if _newclass:
        selHndHydrogen = _swig_property(_ccp4srs.DASelHnds_selHndHydrogen_get, _ccp4srs.DASelHnds_selHndHydrogen_set)
    __swig_setmethods__["selKey"] = _ccp4srs.DASelHnds_selKey_set
    __swig_getmethods__["selKey"] = _ccp4srs.DASelHnds_selKey_get
    if _newclass:
        selKey = _swig_property(_ccp4srs.DASelHnds_selKey_get, _ccp4srs.DASelHnds_selKey_set)

    def getNewHandles(self, MMDB):
        return _ccp4srs.DASelHnds_getNewHandles(self, MMDB)

    def makeSelIndexes(self, MMDB):
        return _ccp4srs.DASelHnds_makeSelIndexes(self, MMDB)

    def deleteSelections(self, MMDB):
        return _ccp4srs.DASelHnds_deleteSelections(self, MMDB)

    def __init__(self):
        this = _ccp4srs.new_DASelHnds()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_DASelHnds
    __del__ = lambda self: None
DASelHnds_swigregister = _ccp4srs.DASelHnds_swigregister
DASelHnds_swigregister(DASelHnds)

class Base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Base, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Base()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Base
    __del__ = lambda self: None

    def loadIndex(self, srsPath):
        return _ccp4srs.Base_loadIndex(self, srsPath)

    def loadStructure(self, entryID):
        return _ccp4srs.Base_loadStructure(self, entryID)

    def getIndex(self, *args):
        return _ccp4srs.Base_getIndex(self, *args)

    def unloadStructure(self, entryID):
        return _ccp4srs.Base_unloadStructure(self, entryID)

    def getPath(self, S, FName):
        return _ccp4srs.Base_getPath(self, S, FName)

    def getStructFile(self):
        return _ccp4srs.Base_getStructFile(self)

    def getGraphFile(self):
        return _ccp4srs.Base_getGraphFile(self)

    def n_entries(self):
        return _ccp4srs.Base_n_entries(self)

    def getEntryNo(self, entryID):
        return _ccp4srs.Base_getEntryNo(self, entryID)

    def getMonomer(self, *args):
        return _ccp4srs.Base_getMonomer(self, *args)

    def getNofAtoms(self, *args):
        return _ccp4srs.Base_getNofAtoms(self, *args)

    def getAtNames(self, *args):
        return _ccp4srs.Base_getAtNames(self, *args)

    def getAtoms(self, entryID, nNonHAtoms, NonHAtName, nHAtoms, HAtName, Hconnect, Elem, Chiral):
        return _ccp4srs.Base_getAtoms(self, entryID, nNonHAtoms, NonHAtName, nHAtoms, HAtName, Hconnect, Elem, Chiral)

    def getBonds(self, entryID, nBonds, bondPair, nAtoms, maxNAtoms, maxNBonds):
        return _ccp4srs.Base_getBonds(self, entryID, nBonds, bondPair, nAtoms, maxNAtoms, maxNBonds)

    def getHetInfo(self, entryID, Formula, Hname, Hsynonym, Hcharge, ClinkAtom, ClinkEle, SlinkAtom, SlinkEle, nLeavingAtoms):
        return _ccp4srs.Base_getHetInfo(self, entryID, Formula, Hname, Hsynonym, Hcharge, ClinkAtom, ClinkEle, SlinkAtom, SlinkEle, nLeavingAtoms)
Base_swigregister = _ccp4srs.Base_swigregister
Base_swigregister(Base)

class Chem(Base):
    __swig_setmethods__ = {}
    for _s in [Base]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chem, name, value)
    __swig_getmethods__ = {}
    for _s in [Base]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Chem, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Chem()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Chem
    __del__ = lambda self: None

    def getEnergyTypes(self, *args):
        return _ccp4srs.Chem_getEnergyTypes(self, *args)

    def addHydrogens(self, *args):
        return _ccp4srs.Chem_addHydrogens(self, *args)

    def makeBonds(self, R, altLoc, structFile, selHandles, ignoreNegSigOcc):
        return _ccp4srs.Chem_makeBonds(self, R, altLoc, structFile, selHandles, ignoreNegSigOcc)

    def CalcHBonds(self, Res1, nres1, Res2, nres2, HBond, nHBonds, SBridge, nSBridges, structFile=None, altLoc=None, ignoreNegSigOcc=False):
        return _ccp4srs.Chem_CalcHBonds(self, Res1, nres1, Res2, nres2, HBond, nHBonds, SBridge, nSBridges, structFile, altLoc, ignoreNegSigOcc)
Chem_swigregister = _ccp4srs.Chem_swigregister
Chem_swigregister(Chem)

class Manager(Chem):
    __swig_setmethods__ = {}
    for _s in [Chem]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Manager, name, value)
    __swig_getmethods__ = {}
    for _s in [Chem]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Manager, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Manager()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Manager
    __del__ = lambda self: None
Manager_swigregister = _ccp4srs.Manager_swigregister
Manager_swigregister(Manager)

class Bond_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bond_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bond_, name)
    __repr__ = _swig_repr
    noOrder = _ccp4srs.Bond__noOrder
    Single = _ccp4srs.Bond__Single
    Aromatic = _ccp4srs.Bond__Aromatic
    Double = _ccp4srs.Bond__Double
    Triple = _ccp4srs.Bond__Triple
    Deloc = _ccp4srs.Bond__Deloc
    Covalent = _ccp4srs.Bond__Covalent
    Metal = _ccp4srs.Bond__Metal

    def __init__(self):
        this = _ccp4srs.new_Bond_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Bond_
    __del__ = lambda self: None

    def atom1(self):
        return _ccp4srs.Bond__atom1(self)

    def atom2(self):
        return _ccp4srs.Bond__atom2(self)

    def order(self):
        return _ccp4srs.Bond__order(self)

    def length(self):
        return _ccp4srs.Bond__length(self)

    def length_esd(self):
        return _ccp4srs.Bond__length_esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Bond__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.Bond__makeCIFTags)

    def readFromCIF_ccp4(self, mmCIFLoop, bondNo, atoms):
        return _ccp4srs.Bond__readFromCIF_ccp4(self, mmCIFLoop, bondNo, atoms)

    def readFromCIF_rcsb(self, mmCIFLoop, bondNo, atoms):
        return _ccp4srs.Bond__readFromCIF_rcsb(self, mmCIFLoop, bondNo, atoms)

    def readFromCIF(self, mmCIFStruct, atoms):
        return _ccp4srs.Bond__readFromCIF(self, mmCIFStruct, atoms)

    def writeToCIF(self, mmCIFLoop, monID, atoms):
        return _ccp4srs.Bond__writeToCIF(self, mmCIFLoop, monID, atoms)

    def compare(self, atoms, bond, bond_atoms):
        return _ccp4srs.Bond__compare(self, atoms, bond, bond_atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.Bond__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.Bond__read_mem(self, memIO, version, Ok)

    def copy(self, *args):
        return _ccp4srs.Bond__copy(self, *args)
Bond__swigregister = _ccp4srs.Bond__swigregister
Bond__swigregister(Bond_)

def Bond__makeCIFTags(mmCIFLoop):
    return _ccp4srs.Bond__makeCIFTags(mmCIFLoop)
Bond__makeCIFTags = _ccp4srs.Bond__makeCIFTags

class Angle_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Angle_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Angle_, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Angle_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Angle_
    __del__ = lambda self: None

    def atom1(self):
        return _ccp4srs.Angle__atom1(self)

    def atom2(self):
        return _ccp4srs.Angle__atom2(self)

    def atom3(self):
        return _ccp4srs.Angle__atom3(self)

    def value(self):
        return _ccp4srs.Angle__value(self)

    def esd(self):
        return _ccp4srs.Angle__esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Angle__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.Angle__makeCIFTags)

    def readFromCIF(self, mmCIFLoop, angleNo, atoms):
        return _ccp4srs.Angle__readFromCIF(self, mmCIFLoop, angleNo, atoms)

    def writeToCIF(self, mmCIFLoop, monID, atoms):
        return _ccp4srs.Angle__writeToCIF(self, mmCIFLoop, monID, atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.Angle__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.Angle__read_mem(self, memIO, version, Ok)

    def copy(self, ang, anmatch=None):
        return _ccp4srs.Angle__copy(self, ang, anmatch)
Angle__swigregister = _ccp4srs.Angle__swigregister
Angle__swigregister(Angle_)

def Angle__makeCIFTags(mmCIFLoop):
    return _ccp4srs.Angle__makeCIFTags(mmCIFLoop)
Angle__makeCIFTags = _ccp4srs.Angle__makeCIFTags

class Plane_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plane_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Plane_, name)
    __repr__ = _swig_repr
    Ok = _ccp4srs.Plane__Ok
    EmptyLoop = _ccp4srs.Plane__EmptyLoop
    NoMorePlanes = _ccp4srs.Plane__NoMorePlanes

    def __init__(self):
        this = _ccp4srs.new_Plane_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Plane_
    __del__ = lambda self: None

    def id(self):
        return _ccp4srs.Plane__id(self)

    def size(self):
        return _ccp4srs.Plane__size(self)

    def atoms(self):
        return _ccp4srs.Plane__atoms(self)

    def esds(self):
        return _ccp4srs.Plane__esds(self)

    def atom(self, atomNo):
        return _ccp4srs.Plane__atom(self, atomNo)

    def esd(self, atomNo):
        return _ccp4srs.Plane__esd(self, atomNo)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Plane__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.Plane__makeCIFTags)

    def readFromCIF(self, mmCIFLoop, planeNo, atoms):
        return _ccp4srs.Plane__readFromCIF(self, mmCIFLoop, planeNo, atoms)

    def writeToCIF(self, mmCIFLoop, monID, atoms):
        return _ccp4srs.Plane__writeToCIF(self, mmCIFLoop, monID, atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.Plane__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.Plane__read_mem(self, memIO, version, Ok)

    def copy(self, plane, anmatch=None):
        return _ccp4srs.Plane__copy(self, plane, anmatch)
Plane__swigregister = _ccp4srs.Plane__swigregister
Plane__swigregister(Plane_)

def Plane__makeCIFTags(mmCIFLoop):
    return _ccp4srs.Plane__makeCIFTags(mmCIFLoop)
Plane__makeCIFTags = _ccp4srs.Plane__makeCIFTags

class SRSAtom_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SRSAtom_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SRSAtom_, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_SRSAtom_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_SRSAtom_
    __del__ = lambda self: None

    def id(self):
        return _ccp4srs.SRSAtom__id(self)

    def name(self):
        return _ccp4srs.SRSAtom__name(self)

    def rcsb_name(self):
        return _ccp4srs.SRSAtom__rcsb_name(self)

    def old_name(self):
        return _ccp4srs.SRSAtom__old_name(self)

    def element(self):
        return _ccp4srs.SRSAtom__element(self)

    def energy_type(self):
        return _ccp4srs.SRSAtom__energy_type(self)

    def x(self):
        return _ccp4srs.SRSAtom__x(self)

    def y(self):
        return _ccp4srs.SRSAtom__y(self)

    def z(self):
        return _ccp4srs.SRSAtom__z(self)

    def x_rcsb_cartn(self):
        return _ccp4srs.SRSAtom__x_rcsb_cartn(self)

    def y_rcsb_cartn(self):
        return _ccp4srs.SRSAtom__y_rcsb_cartn(self)

    def z_rcsb_cartn(self):
        return _ccp4srs.SRSAtom__z_rcsb_cartn(self)

    def x_rcsb_ideal(self):
        return _ccp4srs.SRSAtom__x_rcsb_ideal(self)

    def y_rcsb_ideal(self):
        return _ccp4srs.SRSAtom__y_rcsb_ideal(self)

    def z_rcsb_ideal(self):
        return _ccp4srs.SRSAtom__z_rcsb_ideal(self)

    def x_ccp4_mlib(self):
        return _ccp4srs.SRSAtom__x_ccp4_mlib(self)

    def y_ccp4_mlib(self):
        return _ccp4srs.SRSAtom__y_ccp4_mlib(self)

    def z_ccp4_mlib(self):
        return _ccp4srs.SRSAtom__z_ccp4_mlib(self)

    def charge(self):
        return _ccp4srs.SRSAtom__charge(self)

    def weight(self):
        return _ccp4srs.SRSAtom__weight(self)

    def vdw_radius(self):
        return _ccp4srs.SRSAtom__vdw_radius(self)

    def vdwh_radius(self):
        return _ccp4srs.SRSAtom__vdwh_radius(self)

    def ion_radius(self):
        return _ccp4srs.SRSAtom__ion_radius(self)

    def valency(self):
        return _ccp4srs.SRSAtom__valency(self)

    def sp(self):
        return _ccp4srs.SRSAtom__sp(self)

    def rcsb_chirality(self):
        return _ccp4srs.SRSAtom__rcsb_chirality(self)

    def ccp4_chirality(self):
        return _ccp4srs.SRSAtom__ccp4_chirality(self)

    def chirality(self):
        return _ccp4srs.SRSAtom__chirality(self)

    def leaving(self):
        return _ccp4srs.SRSAtom__leaving(self)

    def isLeaving(self):
        return _ccp4srs.SRSAtom__isLeaving(self)

    def hb_type(self):
        return _ccp4srs.SRSAtom__hb_type(self)

    def ccp4_coordinates(self):
        return _ccp4srs.SRSAtom__ccp4_coordinates(self)

    def name_pdb(self, aname):
        return _ccp4srs.SRSAtom__name_pdb(self, aname)

    def rcsb_name_pdb(self, aname):
        return _ccp4srs.SRSAtom__rcsb_name_pdb(self, aname)

    def old_name_pdb(self, aname):
        return _ccp4srs.SRSAtom__old_name_pdb(self, aname)

    def element_pdb(self, elem):
        return _ccp4srs.SRSAtom__element_pdb(self, elem)

    def set_energy_type(self, etype):
        return _ccp4srs.SRSAtom__set_energy_type(self, etype)

    def set_old_name(self, name):
        return _ccp4srs.SRSAtom__set_old_name(self, name)

    def set_rcsb_chirality(self, c):
        return _ccp4srs.SRSAtom__set_rcsb_chirality(self, c)

    def set_chirality(self, c):
        return _ccp4srs.SRSAtom__set_chirality(self, c)

    def set_hb_type(self, h):
        return _ccp4srs.SRSAtom__set_hb_type(self, h)

    def set_ccp4_coordinates(self, on):
        return _ccp4srs.SRSAtom__set_ccp4_coordinates(self, on)

    def set_vdw_radius(self, r):
        return _ccp4srs.SRSAtom__set_vdw_radius(self, r)

    def set_vdwh_radius(self, r):
        return _ccp4srs.SRSAtom__set_vdwh_radius(self, r)

    def set_ion_radius(self, r):
        return _ccp4srs.SRSAtom__set_ion_radius(self, r)

    def set_valency(self, v):
        return _ccp4srs.SRSAtom__set_valency(self, v)

    def set_sp(self, s):
        return _ccp4srs.SRSAtom__set_sp(self, s)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.SRSAtom__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.SRSAtom__makeCIFTags)

    def readFromCIF_ccp4(self, mmCIFLoop, atomNo):
        return _ccp4srs.SRSAtom__readFromCIF_ccp4(self, mmCIFLoop, atomNo)

    def readFromCIF_rcsb(self, mmCIFLoop, atomNo):
        return _ccp4srs.SRSAtom__readFromCIF_rcsb(self, mmCIFLoop, atomNo)

    def readFromCIF(self, mmCIFStruct):
        return _ccp4srs.SRSAtom__readFromCIF(self, mmCIFStruct)

    def writeToCIF(self, mmCIFLoop, monID):
        return _ccp4srs.SRSAtom__writeToCIF(self, mmCIFLoop, monID)

    def copy(self, atom):
        return _ccp4srs.SRSAtom__copy(self, atom)

    def merge(self, atom):
        return _ccp4srs.SRSAtom__merge(self, atom)

    def write_mem(self, memIO, version):
        return _ccp4srs.SRSAtom__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.SRSAtom__read_mem(self, memIO, version, Ok)
SRSAtom__swigregister = _ccp4srs.SRSAtom__swigregister
SRSAtom__swigregister(SRSAtom_)

def SRSAtom__makeCIFTags(mmCIFLoop):
    return _ccp4srs.SRSAtom__makeCIFTags(mmCIFLoop)
SRSAtom__makeCIFTags = _ccp4srs.SRSAtom__makeCIFTags


def get_atom_from_cif(*args):
    return _ccp4srs.get_atom_from_cif(*args)
get_atom_from_cif = _ccp4srs.get_atom_from_cif

def add_atom_to_cif(loop, atom_no, atoms):
    return _ccp4srs.add_atom_to_cif(loop, atom_no, atoms)
add_atom_to_cif = _ccp4srs.add_atom_to_cif
class Torsion_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Torsion_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Torsion_, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Torsion_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Torsion_
    __del__ = lambda self: None

    def id(self):
        return _ccp4srs.Torsion__id(self)

    def atom1(self):
        return _ccp4srs.Torsion__atom1(self)

    def atom2(self):
        return _ccp4srs.Torsion__atom2(self)

    def atom3(self):
        return _ccp4srs.Torsion__atom3(self)

    def atom4(self):
        return _ccp4srs.Torsion__atom4(self)

    def period(self):
        return _ccp4srs.Torsion__period(self)

    def value(self):
        return _ccp4srs.Torsion__value(self)

    def esd(self):
        return _ccp4srs.Torsion__esd(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.Torsion__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.Torsion__makeCIFTags)

    def readFromCIF(self, mmCIFLoop, angleNo, atoms):
        return _ccp4srs.Torsion__readFromCIF(self, mmCIFLoop, angleNo, atoms)

    def writeToCIF(self, mmCIFLoop, monID, atoms):
        return _ccp4srs.Torsion__writeToCIF(self, mmCIFLoop, monID, atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.Torsion__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.Torsion__read_mem(self, memIO, version, Ok)

    def copy(self, trs, anmatch=None):
        return _ccp4srs.Torsion__copy(self, trs, anmatch)
Torsion__swigregister = _ccp4srs.Torsion__swigregister
Torsion__swigregister(Torsion_)

def Torsion__makeCIFTags(mmCIFLoop):
    return _ccp4srs.Torsion__makeCIFTags(mmCIFLoop)
Torsion__makeCIFTags = _ccp4srs.Torsion__makeCIFTags

class ChiCenter_(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiCenter_, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChiCenter_, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_ChiCenter_()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_ChiCenter_
    __del__ = lambda self: None

    def id(self):
        return _ccp4srs.ChiCenter__id(self)

    def center(self):
        return _ccp4srs.ChiCenter__center(self)

    def atom1(self):
        return _ccp4srs.ChiCenter__atom1(self)

    def atom2(self):
        return _ccp4srs.ChiCenter__atom2(self)

    def atom3(self):
        return _ccp4srs.ChiCenter__atom3(self)

    def sign(self):
        return _ccp4srs.ChiCenter__sign(self)

    def get_chirality(self):
        return _ccp4srs.ChiCenter__get_chirality(self)
    __swig_getmethods__["makeCIFTags"] = lambda x: _ccp4srs.ChiCenter__makeCIFTags
    if _newclass:
        makeCIFTags = staticmethod(_ccp4srs.ChiCenter__makeCIFTags)

    def readFromCIF(self, mmCIFLoop, chiNo, atoms):
        return _ccp4srs.ChiCenter__readFromCIF(self, mmCIFLoop, chiNo, atoms)

    def writeToCIF(self, mmCIFLoop, monID, atoms):
        return _ccp4srs.ChiCenter__writeToCIF(self, mmCIFLoop, monID, atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.ChiCenter__write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.ChiCenter__read_mem(self, memIO, version, Ok)

    def copy(self, chicenter, anmatch=None):
        return _ccp4srs.ChiCenter__copy(self, chicenter, anmatch)
ChiCenter__swigregister = _ccp4srs.ChiCenter__swigregister
ChiCenter__swigregister(ChiCenter_)

def ChiCenter__makeCIFTags(mmCIFLoop):
    return _ccp4srs.ChiCenter__makeCIFTags(mmCIFLoop)
ChiCenter__makeCIFTags = _ccp4srs.ChiCenter__makeCIFTags

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 __init__(self):
        this = _ccp4srs.new_Tree()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Tree
    __del__ = lambda self: None

    def empty(self):
        return _ccp4srs.Tree_empty(self)

    def size(self):
        return _ccp4srs.Tree_size(self)

    def atom(self, secNo):
        return _ccp4srs.Tree_atom(self, secNo)

    def backward(self, secNo):
        return _ccp4srs.Tree_backward(self, secNo)

    def forward(self, secNo):
        return _ccp4srs.Tree_forward(self, secNo)

    def connect(self, secNo):
        return _ccp4srs.Tree_connect(self, secNo)

    def readFromCIF(self, mmCIFLoop, atoms):
        return _ccp4srs.Tree_readFromCIF(self, mmCIFLoop, atoms)

    def writeToCIF(self, mmCIFData, monID, atoms):
        return _ccp4srs.Tree_writeToCIF(self, mmCIFData, monID, atoms)

    def write_mem(self, memIO, version):
        return _ccp4srs.Tree_write_mem(self, memIO, version)

    def read_mem(self, memIO, version, Ok=None):
        return _ccp4srs.Tree_read_mem(self, memIO, version, Ok)

    def copy(self, tree, anmatch=None):
        return _ccp4srs.Tree_copy(self, tree, anmatch)
Tree_swigregister = _ccp4srs.Tree_swigregister
Tree_swigregister(Tree)

class SRSAtom(SRSAtom_):
    __swig_setmethods__ = {}
    for _s in [SRSAtom_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SRSAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [SRSAtom_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SRSAtom, name)
    __repr__ = _swig_repr

    def set_x_ccp4_mlib(self, v):
        return _ccp4srs.SRSAtom_set_x_ccp4_mlib(self, v)

    def set_y_ccp4_mlib(self, v):
        return _ccp4srs.SRSAtom_set_y_ccp4_mlib(self, v)

    def set_z_ccp4_mlib(self, v):
        return _ccp4srs.SRSAtom_set_z_ccp4_mlib(self, v)

    def set_x_rcsb_ideal(self, v):
        return _ccp4srs.SRSAtom_set_x_rcsb_ideal(self, v)

    def set_y_rcsb_ideal(self, v):
        return _ccp4srs.SRSAtom_set_y_rcsb_ideal(self, v)

    def set_z_rcsb_ideal(self, v):
        return _ccp4srs.SRSAtom_set_z_rcsb_ideal(self, v)

    def set_x_rcsb_cartn(self, v):
        return _ccp4srs.SRSAtom_set_x_rcsb_cartn(self, v)

    def set_y_rcsb_cartn(self, v):
        return _ccp4srs.SRSAtom_set_y_rcsb_cartn(self, v)

    def set_z_rcsb_cartn(self, v):
        return _ccp4srs.SRSAtom_set_z_rcsb_cartn(self, v)

    def set_atom_charge(self, v):
        return _ccp4srs.SRSAtom_set_atom_charge(self, v)

    def set_energy_type(self, s):
        return _ccp4srs.SRSAtom_set_energy_type(self, s)

    def set_element(self, s):
        return _ccp4srs.SRSAtom_set_element(self, s)

    def set_name(self, s):
        return _ccp4srs.SRSAtom_set_name(self, s)

    def __init__(self):
        this = _ccp4srs.new_SRSAtom()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_SRSAtom
    __del__ = lambda self: None
SRSAtom_swigregister = _ccp4srs.SRSAtom_swigregister
SRSAtom_swigregister(SRSAtom)

class Bond(Bond_):
    __swig_setmethods__ = {}
    for _s in [Bond_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bond, name, value)
    __swig_getmethods__ = {}
    for _s in [Bond_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Bond, name)
    __repr__ = _swig_repr

    def set_atom_1(self, v):
        return _ccp4srs.Bond_set_atom_1(self, v)

    def set_atom_2(self, v):
        return _ccp4srs.Bond_set_atom_2(self, v)

    def set_bond_order(self, v):
        return _ccp4srs.Bond_set_bond_order(self, v)

    def set_bond_length(self, v):
        return _ccp4srs.Bond_set_bond_length(self, v)

    def set_bond_length_esd(self, v):
        return _ccp4srs.Bond_set_bond_length_esd(self, v)

    def __init__(self):
        this = _ccp4srs.new_Bond()
        try:
            self.this.append(this)
        except:
            self.this = this
Bond_swigregister = _ccp4srs.Bond_swigregister
Bond_swigregister(Bond)

class Angle(Angle_):
    __swig_setmethods__ = {}
    for _s in [Angle_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Angle, name, value)
    __swig_getmethods__ = {}
    for _s in [Angle_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Angle, name)
    __repr__ = _swig_repr

    def set_atom_1(self, v):
        return _ccp4srs.Angle_set_atom_1(self, v)

    def set_atom_2(self, v):
        return _ccp4srs.Angle_set_atom_2(self, v)

    def set_atom_3(self, v):
        return _ccp4srs.Angle_set_atom_3(self, v)

    def set_angle(self, v):
        return _ccp4srs.Angle_set_angle(self, v)

    def set_angle_esd(self, v):
        return _ccp4srs.Angle_set_angle_esd(self, v)

    def __init__(self):
        this = _ccp4srs.new_Angle()
        try:
            self.this.append(this)
        except:
            self.this = this
Angle_swigregister = _ccp4srs.Angle_swigregister
Angle_swigregister(Angle)

class Torsion(Torsion_):
    __swig_setmethods__ = {}
    for _s in [Torsion_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Torsion, name, value)
    __swig_getmethods__ = {}
    for _s in [Torsion_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Torsion, name)
    __repr__ = _swig_repr

    def set_atom_1(self, v):
        return _ccp4srs.Torsion_set_atom_1(self, v)

    def set_atom_2(self, v):
        return _ccp4srs.Torsion_set_atom_2(self, v)

    def set_atom_3(self, v):
        return _ccp4srs.Torsion_set_atom_3(self, v)

    def set_atom_4(self, v):
        return _ccp4srs.Torsion_set_atom_4(self, v)

    def set_period(self, v):
        return _ccp4srs.Torsion_set_period(self, v)

    def set_angle(self, v):
        return _ccp4srs.Torsion_set_angle(self, v)

    def set_angle_esd(self, v):
        return _ccp4srs.Torsion_set_angle_esd(self, v)

    def set_torsion_id(self, s):
        return _ccp4srs.Torsion_set_torsion_id(self, s)

    def __init__(self):
        this = _ccp4srs.new_Torsion()
        try:
            self.this.append(this)
        except:
            self.this = this
Torsion_swigregister = _ccp4srs.Torsion_swigregister
Torsion_swigregister(Torsion)

class ChiCenter(ChiCenter_):
    __swig_setmethods__ = {}
    for _s in [ChiCenter_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiCenter, name, value)
    __swig_getmethods__ = {}
    for _s in [ChiCenter_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChiCenter, name)
    __repr__ = _swig_repr

    def set_atom_center(self, v):
        return _ccp4srs.ChiCenter_set_atom_center(self, v)

    def set_atom_1(self, v):
        return _ccp4srs.ChiCenter_set_atom_1(self, v)

    def set_atom_2(self, v):
        return _ccp4srs.ChiCenter_set_atom_2(self, v)

    def set_atom_3(self, v):
        return _ccp4srs.ChiCenter_set_atom_3(self, v)

    def set_volume_sign(self, v):
        return _ccp4srs.ChiCenter_set_volume_sign(self, v)

    def set_chicenter_id(self, s):
        return _ccp4srs.ChiCenter_set_chicenter_id(self, s)

    def __init__(self):
        this = _ccp4srs.new_ChiCenter()
        try:
            self.this.append(this)
        except:
            self.this = this
ChiCenter_swigregister = _ccp4srs.ChiCenter_swigregister
ChiCenter_swigregister(ChiCenter)

class Plane(Plane_):
    __swig_setmethods__ = {}
    for _s in [Plane_]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Plane, name, value)
    __swig_getmethods__ = {}
    for _s in [Plane_]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Plane, name)
    __repr__ = _swig_repr

    def empty(self):
        return _ccp4srs.Plane_empty(self)

    def set_n_atoms(self, v):
        return _ccp4srs.Plane_set_n_atoms(self, v)

    def set_plane_id(self, s):
        return _ccp4srs.Plane_set_plane_id(self, s)

    def set_plane_atoms(self, v):
        return _ccp4srs.Plane_set_plane_atoms(self, v)

    def set_dist_esds(self, v):
        return _ccp4srs.Plane_set_dist_esds(self, v)

    def __init__(self):
        this = _ccp4srs.new_Plane()
        try:
            self.this.append(this)
        except:
            self.this = this
Plane_swigregister = _ccp4srs.Plane_swigregister
Plane_swigregister(Plane)

class Monomer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Monomer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Monomer, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_Monomer()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Monomer
    __del__ = lambda self: None

    def type(self):
        return _ccp4srs.Monomer_type(self)

    def reset(self):
        return _ccp4srs.Monomer_reset(self)

    def ID(self):
        return _ccp4srs.Monomer_ID(self)

    def oldID(self):
        return _ccp4srs.Monomer_oldID(self)

    def setOldID(self, oldID):
        return _ccp4srs.Monomer_setOldID(self, oldID)

    def chem_name(self):
        return _ccp4srs.Monomer_chem_name(self)

    def chem_type(self):
        return _ccp4srs.Monomer_chem_type(self)

    def chem_formula(self):
        return _ccp4srs.Monomer_chem_formula(self)

    def n_atoms(self):
        return _ccp4srs.Monomer_n_atoms(self)

    def n_bonds(self):
        return _ccp4srs.Monomer_n_bonds(self)

    def n_angles(self):
        return _ccp4srs.Monomer_n_angles(self)

    def n_torsions(self):
        return _ccp4srs.Monomer_n_torsions(self)

    def n_chicenters(self):
        return _ccp4srs.Monomer_n_chicenters(self)

    def n_planes(self):
        return _ccp4srs.Monomer_n_planes(self)

    def atom(self, n):
        return _ccp4srs.Monomer_atom(self, n)

    def bond(self, n):
        return _ccp4srs.Monomer_bond(self, n)

    def angle(self, n):
        return _ccp4srs.Monomer_angle(self, n)

    def plane(self, n):
        return _ccp4srs.Monomer_plane(self, n)

    def tree(self):
        return _ccp4srs.Monomer_tree(self)

    def torsion(self, n):
        return _ccp4srs.Monomer_torsion(self, n)

    def chicenter(self, n):
        return _ccp4srs.Monomer_chicenter(self, n)

    def add(self, *args):
        return _ccp4srs.Monomer_add(self, *args)

    def get_atoms(self):
        return _ccp4srs.Monomer_get_atoms(self)

    def get_bonds(self):
        return _ccp4srs.Monomer_get_bonds(self)

    def get_angles(self):
        return _ccp4srs.Monomer_get_angles(self)

    def get_torsions(self):
        return _ccp4srs.Monomer_get_torsions(self)

    def get_chicenters(self):
        return _ccp4srs.Monomer_get_chicenters(self)

    def get_planes(self):
        return _ccp4srs.Monomer_get_planes(self)

    def get_tree(self):
        return _ccp4srs.Monomer_get_tree(self)

    def getACDLabs(self):
        return _ccp4srs.Monomer_getACDLabs(self)

    def getCACTVS(self):
        return _ccp4srs.Monomer_getCACTVS(self)

    def getOpenEye(self):
        return _ccp4srs.Monomer_getOpenEye(self)

    def getInChI(self):
        return _ccp4srs.Monomer_getInChI(self)

    def atom_no(self, aname):
        return _ccp4srs.Monomer_atom_no(self, aname)

    def get_bound(self, *args):
        return _ccp4srs.Monomer_get_bound(self, *args)

    def addHydrogens(self, R):
        return _ccp4srs.Monomer_addHydrogens(self, R)

    def getAtomNameMatch(self, *args):
        return _ccp4srs.Monomer_getAtomNameMatch(self, *args)

    def getGraph(self, retCode):
        return _ccp4srs.Monomer_getGraph(self, retCode)

    def getLeavingAtoms(self, nLeavingAtoms, leavingAtom, bondedAtom):
        return _ccp4srs.Monomer_getLeavingAtoms(self, nLeavingAtoms, leavingAtom, bondedAtom)

    def readFromCIF(self, mmCIFData, error_desc=None):
        return _ccp4srs.Monomer_readFromCIF(self, mmCIFData, error_desc)

    def makeCIF(self):
        return _ccp4srs.Monomer_makeCIF(self)

    def merge(self, monomer):
        return _ccp4srs.Monomer_merge(self, monomer)

    def check_ccp4_coordinates(self):
        return _ccp4srs.Monomer_check_ccp4_coordinates(self)
Monomer_swigregister = _ccp4srs.Monomer_swigregister
Monomer_swigregister(Monomer)


_ccp4srs.MKGRAPH_Ok_swigconstant(_ccp4srs)
MKGRAPH_Ok = _ccp4srs.MKGRAPH_Ok

_ccp4srs.MKGRAPH_NoAtoms_swigconstant(_ccp4srs)
MKGRAPH_NoAtoms = _ccp4srs.MKGRAPH_NoAtoms

_ccp4srs.MKGRAPH_ChangedAltLoc_swigconstant(_ccp4srs)
MKGRAPH_ChangedAltLoc = _ccp4srs.MKGRAPH_ChangedAltLoc

_ccp4srs.MKGRAPH_MaxOccupancy_swigconstant(_ccp4srs)
MKGRAPH_MaxOccupancy = _ccp4srs.MKGRAPH_MaxOccupancy
class Graph(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Graph, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Graph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _ccp4srs.new_Graph(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Graph
    __del__ = lambda self: None

    def Reset(self):
        return _ccp4srs.Graph_Reset(self)

    def SetName(self, gname):
        return _ccp4srs.Graph_SetName(self, gname)

    def GetName(self):
        return _ccp4srs.Graph_GetName(self)

    def RemoveChirality(self):
        return _ccp4srs.Graph_RemoveChirality(self)

    def LeaveChirality(self, eltype):
        return _ccp4srs.Graph_LeaveChirality(self, eltype)

    def MakeGraph(self, *args):
        return _ccp4srs.Graph_MakeGraph(self, *args)

    def HideType(self, bond_vx_type):
        return _ccp4srs.Graph_HideType(self, bond_vx_type)

    def ExcludeType(self, type):
        return _ccp4srs.Graph_ExcludeType(self, type)

    def MakeSymmetryRelief(self, noCO2):
        return _ccp4srs.Graph_MakeSymmetryRelief(self, noCO2)

    def IdentifyRings(self):
        return _ccp4srs.Graph_IdentifyRings(self)

    def IdentifyConnectedComponents(self):
        return _ccp4srs.Graph_IdentifyConnectedComponents(self)

    def Build(self, bondOrder):
        return _ccp4srs.Graph_Build(self, bondOrder)

    def MakeVertexIDs(self):
        return _ccp4srs.Graph_MakeVertexIDs(self)

    def GetVertexID(self, vertexNo):
        return _ccp4srs.Graph_GetVertexID(self, vertexNo)

    def GetVertexNo(self, vname):
        return _ccp4srs.Graph_GetVertexNo(self, vname)

    def GetNBondedVertices(self, vertexNo):
        return _ccp4srs.Graph_GetNBondedVertices(self, vertexNo)

    def GetBondedVertexID(self, vertexNo, bond_vx_type, bondNo):
        return _ccp4srs.Graph_GetBondedVertexID(self, vertexNo, bond_vx_type, bondNo)

    def GetNofVertices(self):
        return _ccp4srs.Graph_GetNofVertices(self)

    def GetNofEdges(self):
        return _ccp4srs.Graph_GetNofEdges(self)

    def Print(self):
        return _ccp4srs.Graph_Print(self)

    def Print1(self):
        return _ccp4srs.Graph_Print1(self)

    def Copy(self, G):
        return _ccp4srs.Graph_Copy(self, G)
Graph_swigregister = _ccp4srs.Graph_swigregister
Graph_swigregister(Graph)

class GMatch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatch, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _ccp4srs.new_GMatch(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_GMatch
    __del__ = lambda self: None

    def SetMatch(self, FV1, FV2, nv, n, m):
        return _ccp4srs.GMatch_SetMatch(self, FV1, FV2, nv, n, m)

    def isMatch(self, FV1, FV2, nv):
        return _ccp4srs.GMatch_isMatch(self, FV1, FV2, nv)

    def isCombination(self, FV1, FV2, nv):
        return _ccp4srs.GMatch_isCombination(self, FV1, FV2, nv)

    def GetMatch(self, FV1, FV2, nv, p1, p2):
        return _ccp4srs.GMatch_GetMatch(self, FV1, FV2, nv, p1, p2)
GMatch_swigregister = _ccp4srs.GMatch_swigregister
GMatch_swigregister(GMatch)


_ccp4srs.GMF_UniqueMatch_swigconstant(_ccp4srs)
GMF_UniqueMatch = _ccp4srs.GMF_UniqueMatch

_ccp4srs.GMF_NoCombinations_swigconstant(_ccp4srs)
GMF_NoCombinations = _ccp4srs.GMF_NoCombinations

_ccp4srs.EXTTYPE_Ignore_swigconstant(_ccp4srs)
EXTTYPE_Ignore = _ccp4srs.EXTTYPE_Ignore

_ccp4srs.EXTTYPE_Equal_swigconstant(_ccp4srs)
EXTTYPE_Equal = _ccp4srs.EXTTYPE_Equal

_ccp4srs.EXTTYPE_AND_swigconstant(_ccp4srs)
EXTTYPE_AND = _ccp4srs.EXTTYPE_AND

_ccp4srs.EXTTYPE_OR_swigconstant(_ccp4srs)
EXTTYPE_OR = _ccp4srs.EXTTYPE_OR

_ccp4srs.EXTTYPE_XOR_swigconstant(_ccp4srs)
EXTTYPE_XOR = _ccp4srs.EXTTYPE_XOR

_ccp4srs.EXTTYPE_NotEqual_swigconstant(_ccp4srs)
EXTTYPE_NotEqual = _ccp4srs.EXTTYPE_NotEqual

_ccp4srs.EXTTYPE_NotAND_swigconstant(_ccp4srs)
EXTTYPE_NotAND = _ccp4srs.EXTTYPE_NotAND

_ccp4srs.EXTTYPE_NotOR_swigconstant(_ccp4srs)
EXTTYPE_NotOR = _ccp4srs.EXTTYPE_NotOR
class GraphMatch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphMatch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GraphMatch, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _ccp4srs.new_GraphMatch()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_GraphMatch
    __del__ = lambda self: None

    def SetFlag(self, flag):
        return _ccp4srs.GraphMatch_SetFlag(self, flag)

    def RemoveFlag(self, flag):
        return _ccp4srs.GraphMatch_RemoveFlag(self, flag)

    def SetMaxNofMatches(self, maxNofMatches, stopOnMaxN):
        return _ccp4srs.GraphMatch_SetMaxNofMatches(self, maxNofMatches, stopOnMaxN)

    def SetTimeLimit(self, maxTimeToRun=0):
        return _ccp4srs.GraphMatch_SetTimeLimit(self, maxTimeToRun)

    def GetStopSignal(self):
        return _ccp4srs.GraphMatch_GetStopSignal(self)

    def Reset(self):
        return _ccp4srs.GraphMatch_Reset(self)

    def MatchGraphs(self, *args):
        return _ccp4srs.GraphMatch_MatchGraphs(self, *args)

    def PrintMatches(self):
        return _ccp4srs.GraphMatch_PrintMatches(self)

    def GetNofMatches(self):
        return _ccp4srs.GraphMatch_GetNofMatches(self)

    def GetMaxMatchSize(self):
        return _ccp4srs.GraphMatch_GetMaxMatchSize(self)

    def GetMatch(self, *args):
        return _ccp4srs.GraphMatch_GetMatch(self, *args)
GraphMatch_swigregister = _ccp4srs.GraphMatch_swigregister
GraphMatch_swigregister(GraphMatch)

class Residue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Residue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Residue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _ccp4srs.Residue_name_set
    __swig_getmethods__["name"] = _ccp4srs.Residue_name_get
    if _newclass:
        name = _swig_property(_ccp4srs.Residue_name_get, _ccp4srs.Residue_name_set)
    __swig_setmethods__["label_comp_id"] = _ccp4srs.Residue_label_comp_id_set
    __swig_getmethods__["label_comp_id"] = _ccp4srs.Residue_label_comp_id_get
    if _newclass:
        label_comp_id = _swig_property(_ccp4srs.Residue_label_comp_id_get, _ccp4srs.Residue_label_comp_id_set)
    __swig_setmethods__["label_asym_id"] = _ccp4srs.Residue_label_asym_id_set
    __swig_getmethods__["label_asym_id"] = _ccp4srs.Residue_label_asym_id_get
    if _newclass:
        label_asym_id = _swig_property(_ccp4srs.Residue_label_asym_id_get, _ccp4srs.Residue_label_asym_id_set)
    __swig_setmethods__["insCode"] = _ccp4srs.Residue_insCode_set
    __swig_getmethods__["insCode"] = _ccp4srs.Residue_insCode_get
    if _newclass:
        insCode = _swig_property(_ccp4srs.Residue_insCode_get, _ccp4srs.Residue_insCode_set)
    __swig_setmethods__["chain"] = _ccp4srs.Residue_chain_set
    __swig_getmethods__["chain"] = _ccp4srs.Residue_chain_get
    if _newclass:
        chain = _swig_property(_ccp4srs.Residue_chain_get, _ccp4srs.Residue_chain_set)
    __swig_setmethods__["atom"] = _ccp4srs.Residue_atom_set
    __swig_getmethods__["atom"] = _ccp4srs.Residue_atom_get
    if _newclass:
        atom = _swig_property(_ccp4srs.Residue_atom_get, _ccp4srs.Residue_atom_set)
    __swig_setmethods__["seqNum"] = _ccp4srs.Residue_seqNum_set
    __swig_getmethods__["seqNum"] = _ccp4srs.Residue_seqNum_get
    if _newclass:
        seqNum = _swig_property(_ccp4srs.Residue_seqNum_get, _ccp4srs.Residue_seqNum_set)
    __swig_setmethods__["label_seq_id"] = _ccp4srs.Residue_label_seq_id_set
    __swig_getmethods__["label_seq_id"] = _ccp4srs.Residue_label_seq_id_get
    if _newclass:
        label_seq_id = _swig_property(_ccp4srs.Residue_label_seq_id_get, _ccp4srs.Residue_label_seq_id_set)
    __swig_setmethods__["label_entity_id"] = _ccp4srs.Residue_label_entity_id_set
    __swig_getmethods__["label_entity_id"] = _ccp4srs.Residue_label_entity_id_get
    if _newclass:
        label_entity_id = _swig_property(_ccp4srs.Residue_label_entity_id_get, _ccp4srs.Residue_label_entity_id_set)
    __swig_setmethods__["index"] = _ccp4srs.Residue_index_set
    __swig_getmethods__["index"] = _ccp4srs.Residue_index_get
    if _newclass:
        index = _swig_property(_ccp4srs.Residue_index_get, _ccp4srs.Residue_index_set)
    __swig_setmethods__["nAtoms"] = _ccp4srs.Residue_nAtoms_set
    __swig_getmethods__["nAtoms"] = _ccp4srs.Residue_nAtoms_get
    if _newclass:
        nAtoms = _swig_property(_ccp4srs.Residue_nAtoms_get, _ccp4srs.Residue_nAtoms_set)
    __swig_setmethods__["SSE"] = _ccp4srs.Residue_SSE_set
    __swig_getmethods__["SSE"] = _ccp4srs.Residue_SSE_get
    if _newclass:
        SSE = _swig_property(_ccp4srs.Residue_SSE_get, _ccp4srs.Residue_SSE_set)

    def __init__(self, *args):
        this = _ccp4srs.new_Residue(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _ccp4srs.delete_Residue
    __del__ = lambda self: None

    def SetChain(self, Chain_Owner):
        return _ccp4srs.Residue_SetChain(self, Chain_Owner)

    def SetResID(self, resName, sqNum, ins):
        return _ccp4srs.Residue_SetResID(self, resName, sqNum, ins)

    def SetChainID(self, chID):
        return _ccp4srs.Residue_SetChainID(self, chID)

    def GetChain(self):
        return _ccp4srs.Residue_GetChain(self)

    def GetModel(self):
        return _ccp4srs.Residue_GetModel(self)

    def GetModelNum(self):
        return _ccp4srs.Residue_GetModelNum(self)

    def GetChainID(self):
        return _ccp4srs.Residue_GetChainID(self)

    def GetLabelAsymID(self):
        return _ccp4srs.Residue_GetLabelAsymID(self)

    def GetResName(self):
        return _ccp4srs.Residue_GetResName(self)

    def GetLabelCompID(self):
        return _ccp4srs.Residue_GetLabelCompID(self)

    def GetAASimilarity(self, res):
        return _ccp4srs.Residue_GetAASimilarity(self, res)

    def GetAAHydropathy(self):
        return _ccp4srs.Residue_GetAAHydropathy(self)

    def GetSeqNum(self):
        return _ccp4srs.Residue_GetSeqNum(self)

    def GetLabelSeqID(self):
        return _ccp4srs.Residue_GetLabelSeqID(self)

    def GetLabelEntityID(self):
        return _ccp4srs.Residue_GetLabelEntityID(self)

    def GetInsCode(self):
        return _ccp4srs.Residue_GetInsCode(self)

    def GetResidueNo(self):
        return _ccp4srs.Residue_GetResidueNo(self)

    def GetCenter(self, x, y, z):
        return _ccp4srs.Residue_GetCenter(self, x, y, z)

    def GetCoordHierarchy(self):
        return _ccp4srs.Residue_GetCoordHierarchy(self)

    def GetResidueID(self):
        return _ccp4srs.Residue_GetResidueID(self)

    def GetNofAltLocations(self):
        return _ccp4srs.Residue_GetNofAltLocations(self)

    def isAminoacid(self):
        return _ccp4srs.Residue_isAminoacid(self)

    def isNucleotide(self):
        return _ccp4srs.Residue_isNucleotide(self)

    def isDNARNA(self):
        return _ccp4srs.Residue_isDNARNA(self)

    def isSugar(self):
        return _ccp4srs.Residue_isSugar(self)

    def isSolvent(self):
        return _ccp4srs.Residue_isSolvent(self)

    def isModRes(self):
        return _ccp4srs.Residue_isModRes(self)

    def isInSelection(self, selHnd):
        return _ccp4srs.Residue_isInSelection(self, selHnd)

    def isNTerminus(self):
        return _ccp4srs.Residue_isNTerminus(self)

    def isCTerminus(self):
        return _ccp4srs.Residue_isCTerminus(self)

    def CheckID(self, *args):
        return _ccp4srs.Residue_CheckID(self, *args)

    def CheckIDS(self, ID):
        return _ccp4srs.Residue_CheckIDS(self, ID)

    def GetNumberOfAtoms(self, *args):
        return _ccp4srs.Residue_GetNumberOfAtoms(self, *args)

    def GetAtom(self, *args):
        return _ccp4srs.Residue_GetAtom(self, *args)

    def DeleteAtom(self, *args):
        return _ccp4srs.Residue_DeleteAtom(self, *args)

    def DeleteAllAtoms(self):
        return _ccp4srs.Residue_DeleteAllAtoms(self)

    def DeleteAltLocs(self):
        return _ccp4srs.Residue_DeleteAltLocs(self)

    def TrimAtomTable(self):
        return _ccp4srs.Residue_TrimAtomTable(self)

    def PutUDData(self, *args):
        return _ccp4srs.Residue_PutUDData(self, *args)

    def GetUDData(self, *args):
        return _ccp4srs.Residue_GetUDData(self, *args)

    def isMainchainHBond(self, res):
        return _ccp4srs.Residue_isMainchainHBond(self, res)

    def Copy(self, res):
        return _ccp4srs.Residue_Copy(self, res)
Residue_swigregister = _ccp4srs.Residue_swigregister
Residue_swigregister(Residue)

# This file is compatible with both classic and new-style classes.